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. */
130 /* Small local sym to section mapping cache. */
131 struct sym_cache sym_cache;
135 /* Get the RISC-V ELF linker hash table from a link_info structure. */
136 #define riscv_elf_hash_table(p) \
137 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
138 == RISCV_ELF_DATA ? ((struct riscv_elf_link_hash_table *) ((p)->hash)) : NULL)
141 riscv_info_to_howto_rela (bfd *abfd ATTRIBUTE_UNUSED,
143 Elf_Internal_Rela *dst)
145 cache_ptr->howto = riscv_elf_rtype_to_howto (ELFNN_R_TYPE (dst->r_info));
149 riscv_elf_append_rela (bfd *abfd, asection *s, Elf_Internal_Rela *rel)
151 const struct elf_backend_data *bed;
154 bed = get_elf_backend_data (abfd);
155 loc = s->contents + (s->reloc_count++ * bed->s->sizeof_rela);
156 bed->s->swap_reloca_out (abfd, rel, loc);
161 #define PLT_HEADER_INSNS 8
162 #define PLT_ENTRY_INSNS 4
163 #define PLT_HEADER_SIZE (PLT_HEADER_INSNS * 4)
164 #define PLT_ENTRY_SIZE (PLT_ENTRY_INSNS * 4)
166 #define GOT_ENTRY_SIZE RISCV_ELF_WORD_BYTES
168 #define GOTPLT_HEADER_SIZE (2 * GOT_ENTRY_SIZE)
170 #define sec_addr(sec) ((sec)->output_section->vma + (sec)->output_offset)
173 riscv_elf_got_plt_val (bfd_vma plt_index, struct bfd_link_info *info)
175 return sec_addr (riscv_elf_hash_table (info)->elf.sgotplt)
176 + GOTPLT_HEADER_SIZE + (plt_index * GOT_ENTRY_SIZE);
180 # define MATCH_LREG MATCH_LW
182 # define MATCH_LREG MATCH_LD
185 /* Generate a PLT header. */
188 riscv_make_plt_header (bfd_vma gotplt_addr, bfd_vma addr, uint32_t *entry)
190 bfd_vma gotplt_offset_high = RISCV_PCREL_HIGH_PART (gotplt_addr, addr);
191 bfd_vma gotplt_offset_low = RISCV_PCREL_LOW_PART (gotplt_addr, addr);
193 /* auipc t2, %hi(.got.plt)
194 sub t1, t1, t3 # shifted .got.plt offset + hdr size + 12
195 l[w|d] t3, %lo(.got.plt)(t2) # _dl_runtime_resolve
196 addi t1, t1, -(hdr size + 12) # shifted .got.plt offset
197 addi t0, t2, %lo(.got.plt) # &.got.plt
198 srli t1, t1, log2(16/PTRSIZE) # .got.plt offset
199 l[w|d] t0, PTRSIZE(t0) # link map
202 entry[0] = RISCV_UTYPE (AUIPC, X_T2, gotplt_offset_high);
203 entry[1] = RISCV_RTYPE (SUB, X_T1, X_T1, X_T3);
204 entry[2] = RISCV_ITYPE (LREG, X_T3, X_T2, gotplt_offset_low);
205 entry[3] = RISCV_ITYPE (ADDI, X_T1, X_T1, -(PLT_HEADER_SIZE + 12));
206 entry[4] = RISCV_ITYPE (ADDI, X_T0, X_T2, gotplt_offset_low);
207 entry[5] = RISCV_ITYPE (SRLI, X_T1, X_T1, 4 - RISCV_ELF_LOG_WORD_BYTES);
208 entry[6] = RISCV_ITYPE (LREG, X_T0, X_T0, RISCV_ELF_WORD_BYTES);
209 entry[7] = RISCV_ITYPE (JALR, 0, X_T3, 0);
212 /* Generate a PLT entry. */
215 riscv_make_plt_entry (bfd_vma got, bfd_vma addr, uint32_t *entry)
217 /* auipc t3, %hi(.got.plt entry)
218 l[w|d] t3, %lo(.got.plt entry)(t3)
222 entry[0] = RISCV_UTYPE (AUIPC, X_T3, RISCV_PCREL_HIGH_PART (got, addr));
223 entry[1] = RISCV_ITYPE (LREG, X_T3, X_T3, RISCV_PCREL_LOW_PART(got, addr));
224 entry[2] = RISCV_ITYPE (JALR, X_T1, X_T3, 0);
225 entry[3] = RISCV_NOP;
228 /* Create an entry in an RISC-V ELF linker hash table. */
230 static struct bfd_hash_entry *
231 link_hash_newfunc (struct bfd_hash_entry *entry,
232 struct bfd_hash_table *table, const char *string)
234 /* Allocate the structure if it has not already been allocated by a
239 bfd_hash_allocate (table,
240 sizeof (struct riscv_elf_link_hash_entry));
245 /* Call the allocation method of the superclass. */
246 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
249 struct riscv_elf_link_hash_entry *eh;
251 eh = (struct riscv_elf_link_hash_entry *) entry;
252 eh->dyn_relocs = NULL;
253 eh->tls_type = GOT_UNKNOWN;
259 /* Create a RISC-V ELF linker hash table. */
261 static struct bfd_link_hash_table *
262 riscv_elf_link_hash_table_create (bfd *abfd)
264 struct riscv_elf_link_hash_table *ret;
265 bfd_size_type amt = sizeof (struct riscv_elf_link_hash_table);
267 ret = (struct riscv_elf_link_hash_table *) bfd_zmalloc (amt);
271 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc,
272 sizeof (struct riscv_elf_link_hash_entry),
279 return &ret->elf.root;
282 /* Create the .got section. */
285 riscv_elf_create_got_section (bfd *abfd, struct bfd_link_info *info)
289 struct elf_link_hash_entry *h;
290 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
291 struct elf_link_hash_table *htab = elf_hash_table (info);
293 /* This function may be called more than once. */
294 s = bfd_get_linker_section (abfd, ".got");
298 flags = bed->dynamic_sec_flags;
300 s = bfd_make_section_anyway_with_flags (abfd,
301 (bed->rela_plts_and_copies_p
302 ? ".rela.got" : ".rel.got"),
303 (bed->dynamic_sec_flags
306 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
310 s = s_got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
312 || !bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
316 /* The first bit of the global offset table is the header. */
317 s->size += bed->got_header_size;
319 if (bed->want_got_plt)
321 s = bfd_make_section_anyway_with_flags (abfd, ".got.plt", flags);
323 || !bfd_set_section_alignment (abfd, s,
324 bed->s->log_file_align))
328 /* Reserve room for the header. */
329 s->size += GOTPLT_HEADER_SIZE;
332 if (bed->want_got_sym)
334 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
335 section. We don't do this in the linker script because we don't want
336 to define the symbol if we are not creating a global offset
338 h = _bfd_elf_define_linkage_sym (abfd, info, s_got,
339 "_GLOBAL_OFFSET_TABLE_");
340 elf_hash_table (info)->hgot = h;
348 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
349 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
353 riscv_elf_create_dynamic_sections (bfd *dynobj,
354 struct bfd_link_info *info)
356 struct riscv_elf_link_hash_table *htab;
358 htab = riscv_elf_hash_table (info);
359 BFD_ASSERT (htab != NULL);
361 if (!riscv_elf_create_got_section (dynobj, info))
364 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
367 htab->sdynbss = bfd_get_linker_section (dynobj, ".dynbss");
368 if (!bfd_link_pic (info))
370 htab->srelbss = bfd_get_linker_section (dynobj, ".rela.bss");
372 bfd_make_section_anyway_with_flags (dynobj, ".tdata.dyn",
373 SEC_ALLOC | SEC_THREAD_LOCAL);
376 if (!htab->elf.splt || !htab->elf.srelplt || !htab->sdynbss
377 || (!bfd_link_pic (info) && (!htab->srelbss || !htab->sdyntdata)))
383 /* Copy the extra info we tack onto an elf_link_hash_entry. */
386 riscv_elf_copy_indirect_symbol (struct bfd_link_info *info,
387 struct elf_link_hash_entry *dir,
388 struct elf_link_hash_entry *ind)
390 struct riscv_elf_link_hash_entry *edir, *eind;
392 edir = (struct riscv_elf_link_hash_entry *) dir;
393 eind = (struct riscv_elf_link_hash_entry *) ind;
395 if (eind->dyn_relocs != NULL)
397 if (edir->dyn_relocs != NULL)
399 struct riscv_elf_dyn_relocs **pp;
400 struct riscv_elf_dyn_relocs *p;
402 /* Add reloc counts against the indirect sym to the direct sym
403 list. Merge any entries against the same section. */
404 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
406 struct riscv_elf_dyn_relocs *q;
408 for (q = edir->dyn_relocs; q != NULL; q = q->next)
409 if (q->sec == p->sec)
411 q->pc_count += p->pc_count;
412 q->count += p->count;
419 *pp = edir->dyn_relocs;
422 edir->dyn_relocs = eind->dyn_relocs;
423 eind->dyn_relocs = NULL;
426 if (ind->root.type == bfd_link_hash_indirect
427 && dir->got.refcount <= 0)
429 edir->tls_type = eind->tls_type;
430 eind->tls_type = GOT_UNKNOWN;
432 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
436 riscv_elf_record_tls_type (bfd *abfd, struct elf_link_hash_entry *h,
437 unsigned long symndx, char tls_type)
439 char *new_tls_type = &_bfd_riscv_elf_tls_type (abfd, h, symndx);
441 *new_tls_type |= tls_type;
442 if ((*new_tls_type & GOT_NORMAL) && (*new_tls_type & ~GOT_NORMAL))
444 (*_bfd_error_handler)
445 (_("%B: `%s' accessed both as normal and thread local symbol"),
446 abfd, h ? h->root.root.string : "<local>");
453 riscv_elf_record_got_reference (bfd *abfd, struct bfd_link_info *info,
454 struct elf_link_hash_entry *h, long symndx)
456 struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info);
457 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
459 if (htab->elf.sgot == NULL)
461 if (!riscv_elf_create_got_section (htab->elf.dynobj, info))
467 h->got.refcount += 1;
471 /* This is a global offset table entry for a local symbol. */
472 if (elf_local_got_refcounts (abfd) == NULL)
474 bfd_size_type size = symtab_hdr->sh_info * (sizeof (bfd_vma) + 1);
475 if (!(elf_local_got_refcounts (abfd) = bfd_zalloc (abfd, size)))
477 _bfd_riscv_elf_local_got_tls_type (abfd)
478 = (char *) (elf_local_got_refcounts (abfd) + symtab_hdr->sh_info);
480 elf_local_got_refcounts (abfd) [symndx] += 1;
486 bad_static_reloc (bfd *abfd, unsigned r_type, struct elf_link_hash_entry *h)
488 (*_bfd_error_handler)
489 (_("%B: relocation %s against `%s' can not be used when making a shared "
490 "object; recompile with -fPIC"),
491 abfd, riscv_elf_rtype_to_howto (r_type)->name,
492 h != NULL ? h->root.root.string : "a local symbol");
493 bfd_set_error (bfd_error_bad_value);
496 /* Look through the relocs for a section during the first phase, and
497 allocate space in the global offset table or procedure linkage
501 riscv_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
502 asection *sec, const Elf_Internal_Rela *relocs)
504 struct riscv_elf_link_hash_table *htab;
505 Elf_Internal_Shdr *symtab_hdr;
506 struct elf_link_hash_entry **sym_hashes;
507 const Elf_Internal_Rela *rel;
508 asection *sreloc = NULL;
510 if (bfd_link_relocatable (info))
513 htab = riscv_elf_hash_table (info);
514 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
515 sym_hashes = elf_sym_hashes (abfd);
517 if (htab->elf.dynobj == NULL)
518 htab->elf.dynobj = abfd;
520 for (rel = relocs; rel < relocs + sec->reloc_count; rel++)
523 unsigned long r_symndx;
524 struct elf_link_hash_entry *h;
526 r_symndx = ELFNN_R_SYM (rel->r_info);
527 r_type = ELFNN_R_TYPE (rel->r_info);
529 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
531 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
536 if (r_symndx < symtab_hdr->sh_info)
540 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
541 while (h->root.type == bfd_link_hash_indirect
542 || h->root.type == bfd_link_hash_warning)
543 h = (struct elf_link_hash_entry *) h->root.u.i.link;
545 /* PR15323, ref flags aren't set for references in the same
547 h->root.non_ir_ref = 1;
552 case R_RISCV_TLS_GD_HI20:
553 if (!riscv_elf_record_got_reference (abfd, info, h, r_symndx)
554 || !riscv_elf_record_tls_type (abfd, h, r_symndx, GOT_TLS_GD))
558 case R_RISCV_TLS_GOT_HI20:
559 if (bfd_link_pic (info))
560 info->flags |= DF_STATIC_TLS;
561 if (!riscv_elf_record_got_reference (abfd, info, h, r_symndx)
562 || !riscv_elf_record_tls_type (abfd, h, r_symndx, GOT_TLS_IE))
566 case R_RISCV_GOT_HI20:
567 if (!riscv_elf_record_got_reference (abfd, info, h, r_symndx)
568 || !riscv_elf_record_tls_type (abfd, h, r_symndx, GOT_NORMAL))
572 case R_RISCV_CALL_PLT:
573 /* This symbol requires a procedure linkage table entry. We
574 actually build the entry in adjust_dynamic_symbol,
575 because this might be a case of linking PIC code without
576 linking in any dynamic objects, in which case we don't
577 need to generate a procedure linkage table after all. */
582 h->plt.refcount += 1;
589 case R_RISCV_RVC_BRANCH:
590 case R_RISCV_RVC_JUMP:
591 case R_RISCV_PCREL_HI20:
592 /* In shared libraries, these relocs are known to bind locally. */
593 if (bfd_link_pic (info))
597 case R_RISCV_TPREL_HI20:
598 if (!bfd_link_executable (info))
599 return bad_static_reloc (abfd, r_type, h);
601 riscv_elf_record_tls_type (abfd, h, r_symndx, GOT_TLS_LE);
605 if (bfd_link_pic (info))
606 return bad_static_reloc (abfd, r_type, h);
610 case R_RISCV_JUMP_SLOT:
611 case R_RISCV_RELATIVE:
617 /* This reloc might not bind locally. */
621 if (h != NULL && !bfd_link_pic (info))
623 /* We may need a .plt entry if the function this reloc
624 refers to is in a shared lib. */
625 h->plt.refcount += 1;
628 /* If we are creating a shared library, and this is a reloc
629 against a global symbol, or a non PC relative reloc
630 against a local symbol, then we need to copy the reloc
631 into the shared library. However, if we are linking with
632 -Bsymbolic, we do not need to copy a reloc against a
633 global symbol which is defined in an object we are
634 including in the link (i.e., DEF_REGULAR is set). At
635 this point we have not seen all the input files, so it is
636 possible that DEF_REGULAR is not set now but will be set
637 later (it is never cleared). In case of a weak definition,
638 DEF_REGULAR may be cleared later by a strong definition in
639 a shared library. We account for that possibility below by
640 storing information in the relocs_copied field of the hash
641 table entry. A similar situation occurs when creating
642 shared libraries and symbol visibility changes render the
645 If on the other hand, we are creating an executable, we
646 may need to keep relocations for symbols satisfied by a
647 dynamic library if we manage to avoid copy relocs for the
649 if ((bfd_link_pic (info)
650 && (sec->flags & SEC_ALLOC) != 0
651 && (! riscv_elf_rtype_to_howto (r_type)->pc_relative
654 || h->root.type == bfd_link_hash_defweak
655 || !h->def_regular))))
656 || (!bfd_link_pic (info)
657 && (sec->flags & SEC_ALLOC) != 0
659 && (h->root.type == bfd_link_hash_defweak
660 || !h->def_regular)))
662 struct riscv_elf_dyn_relocs *p;
663 struct riscv_elf_dyn_relocs **head;
665 /* When creating a shared object, we must copy these
666 relocs into the output file. We create a reloc
667 section in dynobj and make room for the reloc. */
670 sreloc = _bfd_elf_make_dynamic_reloc_section
671 (sec, htab->elf.dynobj, RISCV_ELF_LOG_WORD_BYTES,
672 abfd, /*rela?*/ TRUE);
678 /* If this is a global symbol, we count the number of
679 relocations we need for this symbol. */
681 head = &((struct riscv_elf_link_hash_entry *) h)->dyn_relocs;
684 /* Track dynamic relocs needed for local syms too.
685 We really need local syms available to do this
690 Elf_Internal_Sym *isym;
692 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
697 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
701 vpp = &elf_section_data (s)->local_dynrel;
702 head = (struct riscv_elf_dyn_relocs **) vpp;
706 if (p == NULL || p->sec != sec)
708 bfd_size_type amt = sizeof *p;
709 p = ((struct riscv_elf_dyn_relocs *)
710 bfd_alloc (htab->elf.dynobj, amt));
721 p->pc_count += riscv_elf_rtype_to_howto (r_type)->pc_relative;
726 case R_RISCV_GNU_VTINHERIT:
727 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
731 case R_RISCV_GNU_VTENTRY:
732 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
745 riscv_elf_gc_mark_hook (asection *sec,
746 struct bfd_link_info *info,
747 Elf_Internal_Rela *rel,
748 struct elf_link_hash_entry *h,
749 Elf_Internal_Sym *sym)
752 switch (ELFNN_R_TYPE (rel->r_info))
754 case R_RISCV_GNU_VTINHERIT:
755 case R_RISCV_GNU_VTENTRY:
759 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
762 /* Update the got entry reference counts for the section being removed. */
765 riscv_elf_gc_sweep_hook (bfd *abfd,
766 struct bfd_link_info *info,
768 const Elf_Internal_Rela *relocs)
770 const Elf_Internal_Rela *rel, *relend;
771 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (abfd);
772 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (abfd);
773 bfd_signed_vma *local_got_refcounts = elf_local_got_refcounts (abfd);
775 if (bfd_link_relocatable (info))
778 elf_section_data (sec)->local_dynrel = NULL;
780 for (rel = relocs, relend = relocs + sec->reloc_count; rel < relend; rel++)
782 unsigned long r_symndx;
783 struct elf_link_hash_entry *h = NULL;
785 r_symndx = ELFNN_R_SYM (rel->r_info);
786 if (r_symndx >= symtab_hdr->sh_info)
788 struct riscv_elf_link_hash_entry *eh;
789 struct riscv_elf_dyn_relocs **pp;
790 struct riscv_elf_dyn_relocs *p;
792 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
793 while (h->root.type == bfd_link_hash_indirect
794 || h->root.type == bfd_link_hash_warning)
795 h = (struct elf_link_hash_entry *) h->root.u.i.link;
796 eh = (struct riscv_elf_link_hash_entry *) h;
797 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
800 /* Everything must go for SEC. */
806 switch (ELFNN_R_TYPE (rel->r_info))
808 case R_RISCV_GOT_HI20:
809 case R_RISCV_TLS_GOT_HI20:
810 case R_RISCV_TLS_GD_HI20:
813 if (h->got.refcount > 0)
818 if (local_got_refcounts &&
819 local_got_refcounts[r_symndx] > 0)
820 local_got_refcounts[r_symndx]--;
825 case R_RISCV_PCREL_HI20:
827 case R_RISCV_JUMP_SLOT:
828 case R_RISCV_RELATIVE:
834 case R_RISCV_RVC_BRANCH:
835 case R_RISCV_RVC_JUMP:
836 if (bfd_link_pic (info))
840 case R_RISCV_CALL_PLT:
843 if (h->plt.refcount > 0)
856 /* Adjust a symbol defined by a dynamic object and referenced by a
857 regular object. The current definition is in some section of the
858 dynamic object, but we're not including those sections. We have to
859 change the definition to something the rest of the link can
863 riscv_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
864 struct elf_link_hash_entry *h)
866 struct riscv_elf_link_hash_table *htab;
867 struct riscv_elf_link_hash_entry * eh;
868 struct riscv_elf_dyn_relocs *p;
872 htab = riscv_elf_hash_table (info);
873 BFD_ASSERT (htab != NULL);
875 dynobj = htab->elf.dynobj;
877 /* Make sure we know what is going on here. */
878 BFD_ASSERT (dynobj != NULL
880 || h->type == STT_GNU_IFUNC
881 || h->u.weakdef != NULL
884 && !h->def_regular)));
886 /* If this is a function, put it in the procedure linkage table. We
887 will fill in the contents of the procedure linkage table later
888 (although we could actually do it here). */
889 if (h->type == STT_FUNC || h->type == STT_GNU_IFUNC || h->needs_plt)
891 if (h->plt.refcount <= 0
892 || SYMBOL_CALLS_LOCAL (info, h)
893 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
894 && h->root.type == bfd_link_hash_undefweak))
896 /* This case can occur if we saw a R_RISCV_CALL_PLT reloc in an
897 input file, but the symbol was never referred to by a dynamic
898 object, or if all references were garbage collected. In such
899 a case, we don't actually need to build a PLT entry. */
900 h->plt.offset = (bfd_vma) -1;
907 h->plt.offset = (bfd_vma) -1;
909 /* If this is a weak symbol, and there is a real definition, the
910 processor independent code will have arranged for us to see the
911 real definition first, and we can just use the same value. */
912 if (h->u.weakdef != NULL)
914 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
915 || h->u.weakdef->root.type == bfd_link_hash_defweak);
916 h->root.u.def.section = h->u.weakdef->root.u.def.section;
917 h->root.u.def.value = h->u.weakdef->root.u.def.value;
921 /* This is a reference to a symbol defined by a dynamic object which
922 is not a function. */
924 /* If we are creating a shared library, we must presume that the
925 only references to the symbol are via the global offset table.
926 For such cases we need not do anything here; the relocations will
927 be handled correctly by relocate_section. */
928 if (bfd_link_pic (info))
931 /* If there are no references to this symbol that do not use the
932 GOT, we don't need to generate a copy reloc. */
936 /* If -z nocopyreloc was given, we won't generate them either. */
937 if (info->nocopyreloc)
943 eh = (struct riscv_elf_link_hash_entry *) h;
944 for (p = eh->dyn_relocs; p != NULL; p = p->next)
946 s = p->sec->output_section;
947 if (s != NULL && (s->flags & SEC_READONLY) != 0)
951 /* If we didn't find any dynamic relocs in read-only sections, then
952 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
959 /* We must allocate the symbol in our .dynbss section, which will
960 become part of the .bss section of the executable. There will be
961 an entry for this symbol in the .dynsym section. The dynamic
962 object will contain position independent code, so all references
963 from the dynamic object to this symbol will go through the global
964 offset table. The dynamic linker will use the .dynsym entry to
965 determine the address it must put in the global offset table, so
966 both the dynamic object and the regular object will refer to the
967 same memory location for the variable. */
969 /* We must generate a R_RISCV_COPY reloc to tell the dynamic linker
970 to copy the initial value out of the dynamic object and into the
971 runtime process image. We need to remember the offset into the
972 .rel.bss section we are going to use. */
973 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
975 htab->srelbss->size += sizeof (ElfNN_External_Rela);
979 if (eh->tls_type & ~GOT_NORMAL)
980 return _bfd_elf_adjust_dynamic_copy (info, h, htab->sdyntdata);
982 return _bfd_elf_adjust_dynamic_copy (info, h, htab->sdynbss);
985 /* Allocate space in .plt, .got and associated reloc sections for
989 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
991 struct bfd_link_info *info;
992 struct riscv_elf_link_hash_table *htab;
993 struct riscv_elf_link_hash_entry *eh;
994 struct riscv_elf_dyn_relocs *p;
996 if (h->root.type == bfd_link_hash_indirect)
999 info = (struct bfd_link_info *) inf;
1000 htab = riscv_elf_hash_table (info);
1001 BFD_ASSERT (htab != NULL);
1003 if (htab->elf.dynamic_sections_created
1004 && h->plt.refcount > 0)
1006 /* Make sure this symbol is output as a dynamic symbol.
1007 Undefined weak syms won't yet be marked as dynamic. */
1008 if (h->dynindx == -1
1009 && !h->forced_local)
1011 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1015 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
1017 asection *s = htab->elf.splt;
1020 s->size = PLT_HEADER_SIZE;
1022 h->plt.offset = s->size;
1024 /* Make room for this entry. */
1025 s->size += PLT_ENTRY_SIZE;
1027 /* We also need to make an entry in the .got.plt section. */
1028 htab->elf.sgotplt->size += GOT_ENTRY_SIZE;
1030 /* We also need to make an entry in the .rela.plt section. */
1031 htab->elf.srelplt->size += sizeof (ElfNN_External_Rela);
1033 /* If this symbol is not defined in a regular file, and we are
1034 not generating a shared library, then set the symbol to this
1035 location in the .plt. This is required to make function
1036 pointers compare as equal between the normal executable and
1037 the shared library. */
1038 if (! bfd_link_pic (info)
1041 h->root.u.def.section = s;
1042 h->root.u.def.value = h->plt.offset;
1047 h->plt.offset = (bfd_vma) -1;
1053 h->plt.offset = (bfd_vma) -1;
1057 if (h->got.refcount > 0)
1061 int tls_type = riscv_elf_hash_entry (h)->tls_type;
1063 /* Make sure this symbol is output as a dynamic symbol.
1064 Undefined weak syms won't yet be marked as dynamic. */
1065 if (h->dynindx == -1
1066 && !h->forced_local)
1068 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1073 h->got.offset = s->size;
1074 dyn = htab->elf.dynamic_sections_created;
1075 if (tls_type & (GOT_TLS_GD | GOT_TLS_IE))
1077 /* TLS_GD needs two dynamic relocs and two GOT slots. */
1078 if (tls_type & GOT_TLS_GD)
1080 s->size += 2 * RISCV_ELF_WORD_BYTES;
1081 htab->elf.srelgot->size += 2 * sizeof (ElfNN_External_Rela);
1084 /* TLS_IE needs one dynamic reloc and one GOT slot. */
1085 if (tls_type & GOT_TLS_IE)
1087 s->size += RISCV_ELF_WORD_BYTES;
1088 htab->elf.srelgot->size += sizeof (ElfNN_External_Rela);
1093 s->size += RISCV_ELF_WORD_BYTES;
1094 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h))
1095 htab->elf.srelgot->size += sizeof (ElfNN_External_Rela);
1099 h->got.offset = (bfd_vma) -1;
1101 eh = (struct riscv_elf_link_hash_entry *) h;
1102 if (eh->dyn_relocs == NULL)
1105 /* In the shared -Bsymbolic case, discard space allocated for
1106 dynamic pc-relative relocs against symbols which turn out to be
1107 defined in regular objects. For the normal shared case, discard
1108 space for pc-relative relocs that have become local due to symbol
1109 visibility changes. */
1111 if (bfd_link_pic (info))
1113 if (SYMBOL_CALLS_LOCAL (info, h))
1115 struct riscv_elf_dyn_relocs **pp;
1117 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1119 p->count -= p->pc_count;
1128 /* Also discard relocs on undefined weak syms with non-default
1130 if (eh->dyn_relocs != NULL
1131 && h->root.type == bfd_link_hash_undefweak)
1133 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
1134 eh->dyn_relocs = NULL;
1136 /* Make sure undefined weak symbols are output as a dynamic
1138 else if (h->dynindx == -1
1139 && !h->forced_local)
1141 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1148 /* For the non-shared case, discard space for relocs against
1149 symbols which turn out to need copy relocs or are not
1155 || (htab->elf.dynamic_sections_created
1156 && (h->root.type == bfd_link_hash_undefweak
1157 || h->root.type == bfd_link_hash_undefined))))
1159 /* Make sure this symbol is output as a dynamic symbol.
1160 Undefined weak syms won't yet be marked as dynamic. */
1161 if (h->dynindx == -1
1162 && !h->forced_local)
1164 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1168 /* If that succeeded, we know we'll be keeping all the
1170 if (h->dynindx != -1)
1174 eh->dyn_relocs = NULL;
1179 /* Finally, allocate space. */
1180 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1182 asection *sreloc = elf_section_data (p->sec)->sreloc;
1183 sreloc->size += p->count * sizeof (ElfNN_External_Rela);
1189 /* Find any dynamic relocs that apply to read-only sections. */
1192 readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
1194 struct riscv_elf_link_hash_entry *eh;
1195 struct riscv_elf_dyn_relocs *p;
1197 eh = (struct riscv_elf_link_hash_entry *) h;
1198 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1200 asection *s = p->sec->output_section;
1202 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1204 ((struct bfd_link_info *) inf)->flags |= DF_TEXTREL;
1212 riscv_elf_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
1214 struct riscv_elf_link_hash_table *htab;
1219 htab = riscv_elf_hash_table (info);
1220 BFD_ASSERT (htab != NULL);
1221 dynobj = htab->elf.dynobj;
1222 BFD_ASSERT (dynobj != NULL);
1224 if (elf_hash_table (info)->dynamic_sections_created)
1226 /* Set the contents of the .interp section to the interpreter. */
1227 if (bfd_link_executable (info) && !info->nointerp)
1229 s = bfd_get_linker_section (dynobj, ".interp");
1230 BFD_ASSERT (s != NULL);
1231 s->size = strlen (ELFNN_DYNAMIC_INTERPRETER) + 1;
1232 s->contents = (unsigned char *) ELFNN_DYNAMIC_INTERPRETER;
1236 /* Set up .got offsets for local syms, and space for local dynamic
1238 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
1240 bfd_signed_vma *local_got;
1241 bfd_signed_vma *end_local_got;
1242 char *local_tls_type;
1243 bfd_size_type locsymcount;
1244 Elf_Internal_Shdr *symtab_hdr;
1247 if (! is_riscv_elf (ibfd))
1250 for (s = ibfd->sections; s != NULL; s = s->next)
1252 struct riscv_elf_dyn_relocs *p;
1254 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
1256 if (!bfd_is_abs_section (p->sec)
1257 && bfd_is_abs_section (p->sec->output_section))
1259 /* Input section has been discarded, either because
1260 it is a copy of a linkonce section or due to
1261 linker script /DISCARD/, so we'll be discarding
1264 else if (p->count != 0)
1266 srel = elf_section_data (p->sec)->sreloc;
1267 srel->size += p->count * sizeof (ElfNN_External_Rela);
1268 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
1269 info->flags |= DF_TEXTREL;
1274 local_got = elf_local_got_refcounts (ibfd);
1278 symtab_hdr = &elf_symtab_hdr (ibfd);
1279 locsymcount = symtab_hdr->sh_info;
1280 end_local_got = local_got + locsymcount;
1281 local_tls_type = _bfd_riscv_elf_local_got_tls_type (ibfd);
1283 srel = htab->elf.srelgot;
1284 for (; local_got < end_local_got; ++local_got, ++local_tls_type)
1288 *local_got = s->size;
1289 s->size += RISCV_ELF_WORD_BYTES;
1290 if (*local_tls_type & GOT_TLS_GD)
1291 s->size += RISCV_ELF_WORD_BYTES;
1292 if (bfd_link_pic (info)
1293 || (*local_tls_type & (GOT_TLS_GD | GOT_TLS_IE)))
1294 srel->size += sizeof (ElfNN_External_Rela);
1297 *local_got = (bfd_vma) -1;
1301 /* Allocate global sym .plt and .got entries, and space for global
1302 sym dynamic relocs. */
1303 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
1305 if (htab->elf.sgotplt)
1307 struct elf_link_hash_entry *got;
1308 got = elf_link_hash_lookup (elf_hash_table (info),
1309 "_GLOBAL_OFFSET_TABLE_",
1310 FALSE, FALSE, FALSE);
1312 /* Don't allocate .got.plt section if there are no GOT nor PLT
1313 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
1315 || !got->ref_regular_nonweak)
1316 && (htab->elf.sgotplt->size == GOTPLT_HEADER_SIZE)
1317 && (htab->elf.splt == NULL
1318 || htab->elf.splt->size == 0)
1319 && (htab->elf.sgot == NULL
1320 || (htab->elf.sgot->size
1321 == get_elf_backend_data (output_bfd)->got_header_size)))
1322 htab->elf.sgotplt->size = 0;
1325 /* The check_relocs and adjust_dynamic_symbol entry points have
1326 determined the sizes of the various dynamic sections. Allocate
1328 for (s = dynobj->sections; s != NULL; s = s->next)
1330 if ((s->flags & SEC_LINKER_CREATED) == 0)
1333 if (s == htab->elf.splt
1334 || s == htab->elf.sgot
1335 || s == htab->elf.sgotplt
1336 || s == htab->sdynbss)
1338 /* Strip this section if we don't need it; see the
1341 else if (strncmp (s->name, ".rela", 5) == 0)
1345 /* We use the reloc_count field as a counter if we need
1346 to copy relocs into the output file. */
1352 /* It's not one of our sections. */
1358 /* If we don't need this section, strip it from the
1359 output file. This is mostly to handle .rela.bss and
1360 .rela.plt. We must create both sections in
1361 create_dynamic_sections, because they must be created
1362 before the linker maps input sections to output
1363 sections. The linker does that before
1364 adjust_dynamic_symbol is called, and it is that
1365 function which decides whether anything needs to go
1366 into these sections. */
1367 s->flags |= SEC_EXCLUDE;
1371 if ((s->flags & SEC_HAS_CONTENTS) == 0)
1374 /* Allocate memory for the section contents. Zero the memory
1375 for the benefit of .rela.plt, which has 4 unused entries
1376 at the beginning, and we don't want garbage. */
1377 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
1378 if (s->contents == NULL)
1382 if (elf_hash_table (info)->dynamic_sections_created)
1384 /* Add some entries to the .dynamic section. We fill in the
1385 values later, in riscv_elf_finish_dynamic_sections, but we
1386 must add the entries now so that we get the correct size for
1387 the .dynamic section. The DT_DEBUG entry is filled in by the
1388 dynamic linker and used by the debugger. */
1389 #define add_dynamic_entry(TAG, VAL) \
1390 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1392 if (bfd_link_executable (info))
1394 if (!add_dynamic_entry (DT_DEBUG, 0))
1398 if (htab->elf.srelplt->size != 0)
1400 if (!add_dynamic_entry (DT_PLTGOT, 0)
1401 || !add_dynamic_entry (DT_PLTRELSZ, 0)
1402 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
1403 || !add_dynamic_entry (DT_JMPREL, 0))
1407 if (!add_dynamic_entry (DT_RELA, 0)
1408 || !add_dynamic_entry (DT_RELASZ, 0)
1409 || !add_dynamic_entry (DT_RELAENT, sizeof (ElfNN_External_Rela)))
1412 /* If any dynamic relocs apply to a read-only section,
1413 then we need a DT_TEXTREL entry. */
1414 if ((info->flags & DF_TEXTREL) == 0)
1415 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, info);
1417 if (info->flags & DF_TEXTREL)
1419 if (!add_dynamic_entry (DT_TEXTREL, 0))
1423 #undef add_dynamic_entry
1429 #define DTP_OFFSET 0x800
1431 /* Return the relocation value for a TLS dtp-relative reloc. */
1434 dtpoff (struct bfd_link_info *info, bfd_vma address)
1436 /* If tls_sec is NULL, we should have signalled an error already. */
1437 if (elf_hash_table (info)->tls_sec == NULL)
1439 return address - elf_hash_table (info)->tls_sec->vma - DTP_OFFSET;
1442 /* Return the relocation value for a static TLS tp-relative relocation. */
1445 tpoff (struct bfd_link_info *info, bfd_vma address)
1447 /* If tls_sec is NULL, we should have signalled an error already. */
1448 if (elf_hash_table (info)->tls_sec == NULL)
1450 return address - elf_hash_table (info)->tls_sec->vma - TP_OFFSET;
1453 /* Return the global pointer's value, or 0 if it is not in use. */
1456 riscv_global_pointer_value (struct bfd_link_info *info)
1458 struct bfd_link_hash_entry *h;
1460 h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
1461 if (h == NULL || h->type != bfd_link_hash_defined)
1464 return h->u.def.value + sec_addr (h->u.def.section);
1467 /* Emplace a static relocation. */
1469 static bfd_reloc_status_type
1470 perform_relocation (const reloc_howto_type *howto,
1471 const Elf_Internal_Rela *rel,
1473 asection *input_section,
1477 if (howto->pc_relative)
1478 value -= sec_addr (input_section) + rel->r_offset;
1479 value += rel->r_addend;
1481 switch (ELFNN_R_TYPE (rel->r_info))
1484 case R_RISCV_TPREL_HI20:
1485 case R_RISCV_PCREL_HI20:
1486 case R_RISCV_GOT_HI20:
1487 case R_RISCV_TLS_GOT_HI20:
1488 case R_RISCV_TLS_GD_HI20:
1489 if (ARCH_SIZE > 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (value)))
1490 return bfd_reloc_overflow;
1491 value = ENCODE_UTYPE_IMM (RISCV_CONST_HIGH_PART (value));
1494 case R_RISCV_LO12_I:
1495 case R_RISCV_GPREL_I:
1496 case R_RISCV_TPREL_LO12_I:
1497 case R_RISCV_PCREL_LO12_I:
1498 value = ENCODE_ITYPE_IMM (value);
1501 case R_RISCV_LO12_S:
1502 case R_RISCV_GPREL_S:
1503 case R_RISCV_TPREL_LO12_S:
1504 case R_RISCV_PCREL_LO12_S:
1505 value = ENCODE_STYPE_IMM (value);
1509 case R_RISCV_CALL_PLT:
1510 if (ARCH_SIZE > 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (value)))
1511 return bfd_reloc_overflow;
1512 value = ENCODE_UTYPE_IMM (RISCV_CONST_HIGH_PART (value))
1513 | (ENCODE_ITYPE_IMM (value) << 32);
1517 if (!VALID_UJTYPE_IMM (value))
1518 return bfd_reloc_overflow;
1519 value = ENCODE_UJTYPE_IMM (value);
1522 case R_RISCV_BRANCH:
1523 if (!VALID_SBTYPE_IMM (value))
1524 return bfd_reloc_overflow;
1525 value = ENCODE_SBTYPE_IMM (value);
1528 case R_RISCV_RVC_BRANCH:
1529 if (!VALID_RVC_B_IMM (value))
1530 return bfd_reloc_overflow;
1531 value = ENCODE_RVC_B_IMM (value);
1534 case R_RISCV_RVC_JUMP:
1535 if (!VALID_RVC_J_IMM (value))
1536 return bfd_reloc_overflow;
1537 value = ENCODE_RVC_J_IMM (value);
1540 case R_RISCV_RVC_LUI:
1541 if (!VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (value)))
1542 return bfd_reloc_overflow;
1543 value = ENCODE_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (value));
1556 case R_RISCV_TLS_DTPREL32:
1557 case R_RISCV_TLS_DTPREL64:
1561 return bfd_reloc_notsupported;
1564 bfd_vma word = bfd_get (howto->bitsize, input_bfd, contents + rel->r_offset);
1565 word = (word & ~howto->dst_mask) | (value & howto->dst_mask);
1566 bfd_put (howto->bitsize, input_bfd, word, contents + rel->r_offset);
1568 return bfd_reloc_ok;
1571 /* Remember all PC-relative high-part relocs we've encountered to help us
1572 later resolve the corresponding low-part relocs. */
1578 } riscv_pcrel_hi_reloc;
1580 typedef struct riscv_pcrel_lo_reloc
1582 asection * input_section;
1583 struct bfd_link_info * info;
1584 reloc_howto_type * howto;
1585 const Elf_Internal_Rela * reloc;
1588 bfd_byte * contents;
1589 struct riscv_pcrel_lo_reloc * next;
1590 } riscv_pcrel_lo_reloc;
1595 riscv_pcrel_lo_reloc *lo_relocs;
1596 } riscv_pcrel_relocs;
1599 riscv_pcrel_reloc_hash (const void *entry)
1601 const riscv_pcrel_hi_reloc *e = entry;
1602 return (hashval_t)(e->address >> 2);
1606 riscv_pcrel_reloc_eq (const void *entry1, const void *entry2)
1608 const riscv_pcrel_hi_reloc *e1 = entry1, *e2 = entry2;
1609 return e1->address == e2->address;
1613 riscv_init_pcrel_relocs (riscv_pcrel_relocs *p)
1616 p->lo_relocs = NULL;
1617 p->hi_relocs = htab_create (1024, riscv_pcrel_reloc_hash,
1618 riscv_pcrel_reloc_eq, free);
1619 return p->hi_relocs != NULL;
1623 riscv_free_pcrel_relocs (riscv_pcrel_relocs *p)
1625 riscv_pcrel_lo_reloc *cur = p->lo_relocs;
1629 riscv_pcrel_lo_reloc *next = cur->next;
1634 htab_delete (p->hi_relocs);
1638 riscv_record_pcrel_hi_reloc (riscv_pcrel_relocs *p, bfd_vma addr, bfd_vma value)
1640 riscv_pcrel_hi_reloc entry = {addr, value - addr};
1641 riscv_pcrel_hi_reloc **slot =
1642 (riscv_pcrel_hi_reloc **) htab_find_slot (p->hi_relocs, &entry, INSERT);
1644 BFD_ASSERT (*slot == NULL);
1645 *slot = (riscv_pcrel_hi_reloc *) bfd_malloc (sizeof (riscv_pcrel_hi_reloc));
1653 riscv_record_pcrel_lo_reloc (riscv_pcrel_relocs *p,
1654 asection *input_section,
1655 struct bfd_link_info *info,
1656 reloc_howto_type *howto,
1657 const Elf_Internal_Rela *reloc,
1662 riscv_pcrel_lo_reloc *entry;
1663 entry = (riscv_pcrel_lo_reloc *) bfd_malloc (sizeof (riscv_pcrel_lo_reloc));
1666 *entry = (riscv_pcrel_lo_reloc) {input_section, info, howto, reloc, addr,
1667 name, contents, p->lo_relocs};
1668 p->lo_relocs = entry;
1673 riscv_resolve_pcrel_lo_relocs (riscv_pcrel_relocs *p)
1675 riscv_pcrel_lo_reloc *r;
1677 for (r = p->lo_relocs; r != NULL; r = r->next)
1679 bfd *input_bfd = r->input_section->owner;
1681 riscv_pcrel_hi_reloc search = {r->addr, 0};
1682 riscv_pcrel_hi_reloc *entry = htab_find (p->hi_relocs, &search);
1685 ((*r->info->callbacks->reloc_overflow)
1686 (r->info, NULL, r->name, r->howto->name, (bfd_vma) 0,
1687 input_bfd, r->input_section, r->reloc->r_offset));
1691 perform_relocation (r->howto, r->reloc, entry->value, r->input_section,
1692 input_bfd, r->contents);
1698 /* Relocate a RISC-V ELF section.
1700 The RELOCATE_SECTION function is called by the new ELF backend linker
1701 to handle the relocations for a section.
1703 The relocs are always passed as Rela structures.
1705 This function is responsible for adjusting the section contents as
1706 necessary, and (if generating a relocatable output file) adjusting
1707 the reloc addend as necessary.
1709 This function does not have to worry about setting the reloc
1710 address or the reloc symbol index.
1712 LOCAL_SYMS is a pointer to the swapped in local symbols.
1714 LOCAL_SECTIONS is an array giving the section in the input file
1715 corresponding to the st_shndx field of each local symbol.
1717 The global hash table entry for the global symbols can be found
1718 via elf_sym_hashes (input_bfd).
1720 When generating relocatable output, this function must handle
1721 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
1722 going to be the section symbol corresponding to the output
1723 section, which means that the addend must be adjusted
1727 riscv_elf_relocate_section (bfd *output_bfd,
1728 struct bfd_link_info *info,
1730 asection *input_section,
1732 Elf_Internal_Rela *relocs,
1733 Elf_Internal_Sym *local_syms,
1734 asection **local_sections)
1736 Elf_Internal_Rela *rel;
1737 Elf_Internal_Rela *relend;
1738 riscv_pcrel_relocs pcrel_relocs;
1739 bfd_boolean ret = FALSE;
1740 asection *sreloc = elf_section_data (input_section)->sreloc;
1741 struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info);
1742 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_bfd);
1743 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
1744 bfd_vma *local_got_offsets = elf_local_got_offsets (input_bfd);
1746 if (!riscv_init_pcrel_relocs (&pcrel_relocs))
1749 relend = relocs + input_section->reloc_count;
1750 for (rel = relocs; rel < relend; rel++)
1752 unsigned long r_symndx;
1753 struct elf_link_hash_entry *h;
1754 Elf_Internal_Sym *sym;
1757 bfd_reloc_status_type r = bfd_reloc_ok;
1759 bfd_vma off, ie_off;
1760 bfd_boolean unresolved_reloc, is_ie = FALSE;
1761 bfd_vma pc = sec_addr (input_section) + rel->r_offset;
1762 int r_type = ELFNN_R_TYPE (rel->r_info), tls_type;
1763 reloc_howto_type *howto = riscv_elf_rtype_to_howto (r_type);
1764 const char *msg = NULL;
1766 if (r_type == R_RISCV_GNU_VTINHERIT || r_type == R_RISCV_GNU_VTENTRY)
1769 /* This is a final link. */
1770 r_symndx = ELFNN_R_SYM (rel->r_info);
1774 unresolved_reloc = FALSE;
1775 if (r_symndx < symtab_hdr->sh_info)
1777 sym = local_syms + r_symndx;
1778 sec = local_sections[r_symndx];
1779 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1783 bfd_boolean warned, ignored;
1785 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1786 r_symndx, symtab_hdr, sym_hashes,
1788 unresolved_reloc, warned, ignored);
1791 /* To avoid generating warning messages about truncated
1792 relocations, set the relocation's address to be the same as
1793 the start of this section. */
1794 if (input_section->output_section != NULL)
1795 relocation = input_section->output_section->vma;
1801 if (sec != NULL && discarded_section (sec))
1802 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
1803 rel, 1, relend, howto, 0, contents);
1805 if (bfd_link_relocatable (info))
1809 name = h->root.root.string;
1812 name = (bfd_elf_string_from_elf_section
1813 (input_bfd, symtab_hdr->sh_link, sym->st_name));
1814 if (name == NULL || *name == '\0')
1815 name = bfd_section_name (input_bfd, sec);
1821 case R_RISCV_TPREL_ADD:
1823 case R_RISCV_JUMP_SLOT:
1824 case R_RISCV_RELATIVE:
1825 /* These require nothing of us at all. */
1829 case R_RISCV_BRANCH:
1830 case R_RISCV_RVC_BRANCH:
1831 case R_RISCV_RVC_LUI:
1832 case R_RISCV_LO12_I:
1833 case R_RISCV_LO12_S:
1834 /* These require no special handling beyond perform_relocation. */
1837 case R_RISCV_GOT_HI20:
1840 bfd_boolean dyn, pic;
1842 off = h->got.offset;
1843 BFD_ASSERT (off != (bfd_vma) -1);
1844 dyn = elf_hash_table (info)->dynamic_sections_created;
1845 pic = bfd_link_pic (info);
1847 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, pic, h)
1848 || (pic && SYMBOL_REFERENCES_LOCAL (info, h)))
1850 /* This is actually a static link, or it is a
1851 -Bsymbolic link and the symbol is defined
1852 locally, or the symbol was forced to be local
1853 because of a version file. We must initialize
1854 this entry in the global offset table. Since the
1855 offset must always be a multiple of the word size,
1856 we use the least significant bit to record whether
1857 we have initialized it already.
1859 When doing a dynamic link, we create a .rela.got
1860 relocation entry to initialize the value. This
1861 is done in the finish_dynamic_symbol routine. */
1866 bfd_put_NN (output_bfd, relocation,
1867 htab->elf.sgot->contents + off);
1872 unresolved_reloc = FALSE;
1876 BFD_ASSERT (local_got_offsets != NULL
1877 && local_got_offsets[r_symndx] != (bfd_vma) -1);
1879 off = local_got_offsets[r_symndx];
1881 /* The offset must always be a multiple of the word size.
1882 So, we can use the least significant bit to record
1883 whether we have already processed this entry. */
1888 if (bfd_link_pic (info))
1891 Elf_Internal_Rela outrel;
1893 /* We need to generate a R_RISCV_RELATIVE reloc
1894 for the dynamic linker. */
1895 s = htab->elf.srelgot;
1896 BFD_ASSERT (s != NULL);
1898 outrel.r_offset = sec_addr (htab->elf.sgot) + off;
1900 ELFNN_R_INFO (0, R_RISCV_RELATIVE);
1901 outrel.r_addend = relocation;
1903 riscv_elf_append_rela (output_bfd, s, &outrel);
1906 bfd_put_NN (output_bfd, relocation,
1907 htab->elf.sgot->contents + off);
1908 local_got_offsets[r_symndx] |= 1;
1911 relocation = sec_addr (htab->elf.sgot) + off;
1912 if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs, pc, relocation))
1913 r = bfd_reloc_overflow;
1921 bfd_vma old_value = bfd_get (howto->bitsize, input_bfd,
1922 contents + rel->r_offset);
1923 relocation = old_value + relocation;
1932 bfd_vma old_value = bfd_get (howto->bitsize, input_bfd,
1933 contents + rel->r_offset);
1934 relocation = old_value - relocation;
1938 case R_RISCV_CALL_PLT:
1941 case R_RISCV_RVC_JUMP:
1942 if (bfd_link_pic (info) && h != NULL && h->plt.offset != MINUS_ONE)
1944 /* Refer to the PLT entry. */
1945 relocation = sec_addr (htab->elf.splt) + h->plt.offset;
1946 unresolved_reloc = FALSE;
1950 case R_RISCV_TPREL_HI20:
1951 relocation = tpoff (info, relocation);
1954 case R_RISCV_TPREL_LO12_I:
1955 case R_RISCV_TPREL_LO12_S:
1956 relocation = tpoff (info, relocation);
1957 if (VALID_ITYPE_IMM (relocation + rel->r_addend))
1959 /* We can use tp as the base register. */
1960 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
1961 insn &= ~(OP_MASK_RS1 << OP_SH_RS1);
1962 insn |= X_TP << OP_SH_RS1;
1963 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
1967 case R_RISCV_GPREL_I:
1968 case R_RISCV_GPREL_S:
1970 bfd_vma gp = riscv_global_pointer_value (info);
1971 bfd_boolean x0_base = VALID_ITYPE_IMM (relocation + rel->r_addend);
1972 if (x0_base || VALID_ITYPE_IMM (relocation + rel->r_addend - gp))
1974 /* We can use x0 or gp as the base register. */
1975 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
1976 insn &= ~(OP_MASK_RS1 << OP_SH_RS1);
1979 rel->r_addend -= gp;
1980 insn |= X_GP << OP_SH_RS1;
1982 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
1985 r = bfd_reloc_overflow;
1989 case R_RISCV_PCREL_HI20:
1990 if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs, pc,
1991 relocation + rel->r_addend))
1992 r = bfd_reloc_overflow;
1995 case R_RISCV_PCREL_LO12_I:
1996 case R_RISCV_PCREL_LO12_S:
1997 if (riscv_record_pcrel_lo_reloc (&pcrel_relocs, input_section, info,
1998 howto, rel, relocation, name,
2001 r = bfd_reloc_overflow;
2004 case R_RISCV_TLS_DTPREL32:
2005 case R_RISCV_TLS_DTPREL64:
2006 relocation = dtpoff (info, relocation);
2011 if ((input_section->flags & SEC_ALLOC) == 0)
2014 if ((bfd_link_pic (info)
2016 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2017 || h->root.type != bfd_link_hash_undefweak)
2018 && (! howto->pc_relative
2019 || !SYMBOL_CALLS_LOCAL (info, h)))
2020 || (!bfd_link_pic (info)
2026 || h->root.type == bfd_link_hash_undefweak
2027 || h->root.type == bfd_link_hash_undefined)))
2029 Elf_Internal_Rela outrel;
2030 bfd_boolean skip_static_relocation, skip_dynamic_relocation;
2032 /* When generating a shared object, these relocations
2033 are copied into the output file to be resolved at run
2037 _bfd_elf_section_offset (output_bfd, info, input_section,
2039 skip_static_relocation = outrel.r_offset != (bfd_vma) -2;
2040 skip_dynamic_relocation = outrel.r_offset >= (bfd_vma) -2;
2041 outrel.r_offset += sec_addr (input_section);
2043 if (skip_dynamic_relocation)
2044 memset (&outrel, 0, sizeof outrel);
2045 else if (h != NULL && h->dynindx != -1
2046 && !(bfd_link_pic (info)
2047 && SYMBOLIC_BIND (info, h)
2050 outrel.r_info = ELFNN_R_INFO (h->dynindx, r_type);
2051 outrel.r_addend = rel->r_addend;
2055 outrel.r_info = ELFNN_R_INFO (0, R_RISCV_RELATIVE);
2056 outrel.r_addend = relocation + rel->r_addend;
2059 riscv_elf_append_rela (output_bfd, sreloc, &outrel);
2060 if (skip_static_relocation)
2065 case R_RISCV_TLS_GOT_HI20:
2069 case R_RISCV_TLS_GD_HI20:
2072 off = h->got.offset;
2077 off = local_got_offsets[r_symndx];
2078 local_got_offsets[r_symndx] |= 1;
2081 tls_type = _bfd_riscv_elf_tls_type (input_bfd, h, r_symndx);
2082 BFD_ASSERT (tls_type & (GOT_TLS_IE | GOT_TLS_GD));
2083 /* If this symbol is referenced by both GD and IE TLS, the IE
2084 reference's GOT slot follows the GD reference's slots. */
2086 if ((tls_type & GOT_TLS_GD) && (tls_type & GOT_TLS_IE))
2087 ie_off = 2 * GOT_ENTRY_SIZE;
2093 Elf_Internal_Rela outrel;
2095 bfd_boolean need_relocs = FALSE;
2097 if (htab->elf.srelgot == NULL)
2102 bfd_boolean dyn, pic;
2103 dyn = htab->elf.dynamic_sections_created;
2104 pic = bfd_link_pic (info);
2106 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, pic, h)
2107 && (!pic || !SYMBOL_REFERENCES_LOCAL (info, h)))
2111 /* The GOT entries have not been initialized yet. Do it
2112 now, and emit any relocations. */
2113 if ((bfd_link_pic (info) || indx != 0)
2115 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2116 || h->root.type != bfd_link_hash_undefweak))
2119 if (tls_type & GOT_TLS_GD)
2123 outrel.r_offset = sec_addr (htab->elf.sgot) + off;
2124 outrel.r_addend = 0;
2125 outrel.r_info = ELFNN_R_INFO (indx, R_RISCV_TLS_DTPMODNN);
2126 bfd_put_NN (output_bfd, 0,
2127 htab->elf.sgot->contents + off);
2128 riscv_elf_append_rela (output_bfd, htab->elf.srelgot, &outrel);
2131 BFD_ASSERT (! unresolved_reloc);
2132 bfd_put_NN (output_bfd,
2133 dtpoff (info, relocation),
2134 (htab->elf.sgot->contents + off +
2135 RISCV_ELF_WORD_BYTES));
2139 bfd_put_NN (output_bfd, 0,
2140 (htab->elf.sgot->contents + off +
2141 RISCV_ELF_WORD_BYTES));
2142 outrel.r_info = ELFNN_R_INFO (indx, R_RISCV_TLS_DTPRELNN);
2143 outrel.r_offset += RISCV_ELF_WORD_BYTES;
2144 riscv_elf_append_rela (output_bfd, htab->elf.srelgot, &outrel);
2149 /* If we are not emitting relocations for a
2150 general dynamic reference, then we must be in a
2151 static link or an executable link with the
2152 symbol binding locally. Mark it as belonging
2153 to module 1, the executable. */
2154 bfd_put_NN (output_bfd, 1,
2155 htab->elf.sgot->contents + off);
2156 bfd_put_NN (output_bfd,
2157 dtpoff (info, relocation),
2158 (htab->elf.sgot->contents + off +
2159 RISCV_ELF_WORD_BYTES));
2163 if (tls_type & GOT_TLS_IE)
2167 bfd_put_NN (output_bfd, 0,
2168 htab->elf.sgot->contents + off + ie_off);
2169 outrel.r_offset = sec_addr (htab->elf.sgot)
2171 outrel.r_addend = 0;
2173 outrel.r_addend = tpoff (info, relocation);
2174 outrel.r_info = ELFNN_R_INFO (indx, R_RISCV_TLS_TPRELNN);
2175 riscv_elf_append_rela (output_bfd, htab->elf.srelgot, &outrel);
2179 bfd_put_NN (output_bfd, tpoff (info, relocation),
2180 htab->elf.sgot->contents + off + ie_off);
2185 BFD_ASSERT (off < (bfd_vma) -2);
2186 relocation = sec_addr (htab->elf.sgot) + off + (is_ie ? ie_off : 0);
2187 if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs, pc, relocation))
2188 r = bfd_reloc_overflow;
2189 unresolved_reloc = FALSE;
2193 r = bfd_reloc_notsupported;
2196 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2197 because such sections are not SEC_ALLOC and thus ld.so will
2198 not process them. */
2199 if (unresolved_reloc
2200 && !((input_section->flags & SEC_DEBUGGING) != 0
2202 && _bfd_elf_section_offset (output_bfd, info, input_section,
2203 rel->r_offset) != (bfd_vma) -1)
2205 (*_bfd_error_handler)
2206 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
2209 (long) rel->r_offset,
2211 h->root.root.string);
2215 if (r == bfd_reloc_ok)
2216 r = perform_relocation (howto, rel, relocation, input_section,
2217 input_bfd, contents);
2224 case bfd_reloc_overflow:
2225 info->callbacks->reloc_overflow
2226 (info, (h ? &h->root : NULL), name, howto->name,
2227 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
2230 case bfd_reloc_undefined:
2231 info->callbacks->undefined_symbol
2232 (info, name, input_bfd, input_section, rel->r_offset,
2236 case bfd_reloc_outofrange:
2237 msg = _("internal error: out of range error");
2240 case bfd_reloc_notsupported:
2241 msg = _("internal error: unsupported relocation error");
2244 case bfd_reloc_dangerous:
2245 msg = _("internal error: dangerous relocation");
2249 msg = _("internal error: unknown error");
2254 info->callbacks->warning
2255 (info, msg, name, input_bfd, input_section, rel->r_offset);
2259 ret = riscv_resolve_pcrel_lo_relocs (&pcrel_relocs);
2261 riscv_free_pcrel_relocs (&pcrel_relocs);
2265 /* Finish up dynamic symbol handling. We set the contents of various
2266 dynamic sections here. */
2269 riscv_elf_finish_dynamic_symbol (bfd *output_bfd,
2270 struct bfd_link_info *info,
2271 struct elf_link_hash_entry *h,
2272 Elf_Internal_Sym *sym)
2274 struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info);
2275 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
2277 if (h->plt.offset != (bfd_vma) -1)
2279 /* We've decided to create a PLT entry for this symbol. */
2281 bfd_vma i, header_address, plt_idx, got_address;
2282 uint32_t plt_entry[PLT_ENTRY_INSNS];
2283 Elf_Internal_Rela rela;
2285 BFD_ASSERT (h->dynindx != -1);
2287 /* Calculate the address of the PLT header. */
2288 header_address = sec_addr (htab->elf.splt);
2290 /* Calculate the index of the entry. */
2291 plt_idx = (h->plt.offset - PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
2293 /* Calculate the address of the .got.plt entry. */
2294 got_address = riscv_elf_got_plt_val (plt_idx, info);
2296 /* Find out where the .plt entry should go. */
2297 loc = htab->elf.splt->contents + h->plt.offset;
2299 /* Fill in the PLT entry itself. */
2300 riscv_make_plt_entry (got_address, header_address + h->plt.offset,
2302 for (i = 0; i < PLT_ENTRY_INSNS; i++)
2303 bfd_put_32 (output_bfd, plt_entry[i], loc + 4*i);
2305 /* Fill in the initial value of the .got.plt entry. */
2306 loc = htab->elf.sgotplt->contents
2307 + (got_address - sec_addr (htab->elf.sgotplt));
2308 bfd_put_NN (output_bfd, sec_addr (htab->elf.splt), loc);
2310 /* Fill in the entry in the .rela.plt section. */
2311 rela.r_offset = got_address;
2313 rela.r_info = ELFNN_R_INFO (h->dynindx, R_RISCV_JUMP_SLOT);
2315 loc = htab->elf.srelplt->contents + plt_idx * sizeof (ElfNN_External_Rela);
2316 bed->s->swap_reloca_out (output_bfd, &rela, loc);
2318 if (!h->def_regular)
2320 /* Mark the symbol as undefined, rather than as defined in
2321 the .plt section. Leave the value alone. */
2322 sym->st_shndx = SHN_UNDEF;
2323 /* If the symbol is weak, we do need to clear the value.
2324 Otherwise, the PLT entry would provide a definition for
2325 the symbol even if the symbol wasn't defined anywhere,
2326 and so the symbol would never be NULL. */
2327 if (!h->ref_regular_nonweak)
2332 if (h->got.offset != (bfd_vma) -1
2333 && !(riscv_elf_hash_entry(h)->tls_type & (GOT_TLS_GD | GOT_TLS_IE)))
2337 Elf_Internal_Rela rela;
2339 /* This symbol has an entry in the GOT. Set it up. */
2341 sgot = htab->elf.sgot;
2342 srela = htab->elf.srelgot;
2343 BFD_ASSERT (sgot != NULL && srela != NULL);
2345 rela.r_offset = sec_addr (sgot) + (h->got.offset &~ (bfd_vma) 1);
2347 /* If this is a -Bsymbolic link, and the symbol is defined
2348 locally, we just want to emit a RELATIVE reloc. Likewise if
2349 the symbol was forced to be local because of a version file.
2350 The entry in the global offset table will already have been
2351 initialized in the relocate_section function. */
2352 if (bfd_link_pic (info)
2353 && (info->symbolic || h->dynindx == -1)
2356 asection *sec = h->root.u.def.section;
2357 rela.r_info = ELFNN_R_INFO (0, R_RISCV_RELATIVE);
2358 rela.r_addend = (h->root.u.def.value
2359 + sec->output_section->vma
2360 + sec->output_offset);
2364 BFD_ASSERT (h->dynindx != -1);
2365 rela.r_info = ELFNN_R_INFO (h->dynindx, R_RISCV_NN);
2369 bfd_put_NN (output_bfd, 0,
2370 sgot->contents + (h->got.offset & ~(bfd_vma) 1));
2371 riscv_elf_append_rela (output_bfd, srela, &rela);
2376 Elf_Internal_Rela rela;
2378 /* This symbols needs a copy reloc. Set it up. */
2379 BFD_ASSERT (h->dynindx != -1);
2381 rela.r_offset = sec_addr (h->root.u.def.section) + h->root.u.def.value;
2382 rela.r_info = ELFNN_R_INFO (h->dynindx, R_RISCV_COPY);
2384 riscv_elf_append_rela (output_bfd, htab->srelbss, &rela);
2387 /* Mark some specially defined symbols as absolute. */
2388 if (h == htab->elf.hdynamic
2389 || (h == htab->elf.hgot || h == htab->elf.hplt))
2390 sym->st_shndx = SHN_ABS;
2395 /* Finish up the dynamic sections. */
2398 riscv_finish_dyn (bfd *output_bfd, struct bfd_link_info *info,
2399 bfd *dynobj, asection *sdyn)
2401 struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info);
2402 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
2403 size_t dynsize = bed->s->sizeof_dyn;
2404 bfd_byte *dyncon, *dynconend;
2406 dynconend = sdyn->contents + sdyn->size;
2407 for (dyncon = sdyn->contents; dyncon < dynconend; dyncon += dynsize)
2409 Elf_Internal_Dyn dyn;
2412 bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
2417 s = htab->elf.sgotplt;
2418 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
2421 s = htab->elf.srelplt;
2422 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
2425 s = htab->elf.srelplt;
2426 dyn.d_un.d_val = s->size;
2432 bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
2438 riscv_elf_finish_dynamic_sections (bfd *output_bfd,
2439 struct bfd_link_info *info)
2443 struct riscv_elf_link_hash_table *htab;
2445 htab = riscv_elf_hash_table (info);
2446 BFD_ASSERT (htab != NULL);
2447 dynobj = htab->elf.dynobj;
2449 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
2451 if (elf_hash_table (info)->dynamic_sections_created)
2456 splt = htab->elf.splt;
2457 BFD_ASSERT (splt != NULL && sdyn != NULL);
2459 ret = riscv_finish_dyn (output_bfd, info, dynobj, sdyn);
2464 /* Fill in the head and tail entries in the procedure linkage table. */
2468 uint32_t plt_header[PLT_HEADER_INSNS];
2469 riscv_make_plt_header (sec_addr (htab->elf.sgotplt),
2470 sec_addr (splt), plt_header);
2472 for (i = 0; i < PLT_HEADER_INSNS; i++)
2473 bfd_put_32 (output_bfd, plt_header[i], splt->contents + 4*i);
2476 elf_section_data (splt->output_section)->this_hdr.sh_entsize
2480 if (htab->elf.sgotplt)
2482 asection *output_section = htab->elf.sgotplt->output_section;
2484 if (bfd_is_abs_section (output_section))
2486 (*_bfd_error_handler)
2487 (_("discarded output section: `%A'"), htab->elf.sgotplt);
2491 if (htab->elf.sgotplt->size > 0)
2493 /* Write the first two entries in .got.plt, needed for the dynamic
2495 bfd_put_NN (output_bfd, (bfd_vma) -1, htab->elf.sgotplt->contents);
2496 bfd_put_NN (output_bfd, (bfd_vma) 0,
2497 htab->elf.sgotplt->contents + GOT_ENTRY_SIZE);
2500 elf_section_data (output_section)->this_hdr.sh_entsize = GOT_ENTRY_SIZE;
2505 asection *output_section = htab->elf.sgot->output_section;
2507 if (htab->elf.sgot->size > 0)
2509 /* Set the first entry in the global offset table to the address of
2510 the dynamic section. */
2511 bfd_vma val = sdyn ? sec_addr (sdyn) : 0;
2512 bfd_put_NN (output_bfd, val, htab->elf.sgot->contents);
2515 elf_section_data (output_section)->this_hdr.sh_entsize = GOT_ENTRY_SIZE;
2521 /* Return address for Ith PLT stub in section PLT, for relocation REL
2522 or (bfd_vma) -1 if it should not be included. */
2525 riscv_elf_plt_sym_val (bfd_vma i, const asection *plt,
2526 const arelent *rel ATTRIBUTE_UNUSED)
2528 return plt->vma + PLT_HEADER_SIZE + i * PLT_ENTRY_SIZE;
2531 static enum elf_reloc_type_class
2532 riscv_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
2533 const asection *rel_sec ATTRIBUTE_UNUSED,
2534 const Elf_Internal_Rela *rela)
2536 switch (ELFNN_R_TYPE (rela->r_info))
2538 case R_RISCV_RELATIVE:
2539 return reloc_class_relative;
2540 case R_RISCV_JUMP_SLOT:
2541 return reloc_class_plt;
2543 return reloc_class_copy;
2545 return reloc_class_normal;
2549 /* Merge backend specific data from an object file to the output
2550 object file when linking. */
2553 _bfd_riscv_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
2555 bfd *obfd = info->output_bfd;
2556 flagword new_flags = elf_elfheader (ibfd)->e_flags;
2557 flagword old_flags = elf_elfheader (obfd)->e_flags;
2559 if (!is_riscv_elf (ibfd) || !is_riscv_elf (obfd))
2562 if (strcmp (bfd_get_target (ibfd), bfd_get_target (obfd)) != 0)
2564 (*_bfd_error_handler)
2565 (_("%B: ABI is incompatible with that of the selected emulation"),
2570 if (!_bfd_elf_merge_object_attributes (ibfd, info))
2573 if (! elf_flags_init (obfd))
2575 elf_flags_init (obfd) = TRUE;
2576 elf_elfheader (obfd)->e_flags = new_flags;
2580 /* Disallow linking soft-float and hard-float. */
2581 if ((old_flags ^ new_flags) & EF_RISCV_SOFT_FLOAT)
2583 (*_bfd_error_handler)
2584 (_("%B: can't link hard-float modules with soft-float modules"), ibfd);
2588 /* Allow linking RVC and non-RVC, and keep the RVC flag. */
2589 elf_elfheader (obfd)->e_flags |= new_flags & EF_RISCV_RVC;
2594 bfd_set_error (bfd_error_bad_value);
2598 /* Delete some bytes from a section while relaxing. */
2601 riscv_relax_delete_bytes (bfd *abfd, asection *sec, bfd_vma addr, size_t count)
2603 unsigned int i, symcount;
2604 bfd_vma toaddr = sec->size;
2605 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (abfd);
2606 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2607 unsigned int sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
2608 struct bfd_elf_section_data *data = elf_section_data (sec);
2609 bfd_byte *contents = data->this_hdr.contents;
2611 /* Actually delete the bytes. */
2613 memmove (contents + addr, contents + addr + count, toaddr - addr - count);
2615 /* Adjust the location of all of the relocs. Note that we need not
2616 adjust the addends, since all PC-relative references must be against
2617 symbols, which we will adjust below. */
2618 for (i = 0; i < sec->reloc_count; i++)
2619 if (data->relocs[i].r_offset > addr && data->relocs[i].r_offset < toaddr)
2620 data->relocs[i].r_offset -= count;
2622 /* Adjust the local symbols defined in this section. */
2623 for (i = 0; i < symtab_hdr->sh_info; i++)
2625 Elf_Internal_Sym *sym = (Elf_Internal_Sym *) symtab_hdr->contents + i;
2626 if (sym->st_shndx == sec_shndx)
2628 /* If the symbol is in the range of memory we just moved, we
2629 have to adjust its value. */
2630 if (sym->st_value > addr && sym->st_value <= toaddr)
2631 sym->st_value -= count;
2633 /* If the symbol *spans* the bytes we just deleted (i.e. its
2634 *end* is in the moved bytes but its *start* isn't), then we
2635 must adjust its size. */
2636 if (sym->st_value <= addr
2637 && sym->st_value + sym->st_size > addr
2638 && sym->st_value + sym->st_size <= toaddr)
2639 sym->st_size -= count;
2643 /* Now adjust the global symbols defined in this section. */
2644 symcount = ((symtab_hdr->sh_size / sizeof (ElfNN_External_Sym))
2645 - symtab_hdr->sh_info);
2647 for (i = 0; i < symcount; i++)
2649 struct elf_link_hash_entry *sym_hash = sym_hashes[i];
2651 if ((sym_hash->root.type == bfd_link_hash_defined
2652 || sym_hash->root.type == bfd_link_hash_defweak)
2653 && sym_hash->root.u.def.section == sec)
2655 /* As above, adjust the value if needed. */
2656 if (sym_hash->root.u.def.value > addr
2657 && sym_hash->root.u.def.value <= toaddr)
2658 sym_hash->root.u.def.value -= count;
2660 /* As above, adjust the size if needed. */
2661 if (sym_hash->root.u.def.value <= addr
2662 && sym_hash->root.u.def.value + sym_hash->size > addr
2663 && sym_hash->root.u.def.value + sym_hash->size <= toaddr)
2664 sym_hash->size -= count;
2671 /* Relax AUIPC + JALR into JAL. */
2674 _bfd_riscv_relax_call (bfd *abfd, asection *sec, asection *sym_sec,
2675 struct bfd_link_info *link_info,
2676 Elf_Internal_Rela *rel,
2678 unsigned int max_alignment,
2681 bfd_byte *contents = elf_section_data (sec)->this_hdr.contents;
2682 bfd_signed_vma foff = symval - (sec_addr (sec) + rel->r_offset);
2683 bfd_boolean near_zero = (symval + RISCV_IMM_REACH/2) < RISCV_IMM_REACH;
2684 bfd_vma auipc, jalr;
2685 int rd, r_type, len = 4, rvc = elf_elfheader (abfd)->e_flags & EF_RISCV_RVC;
2687 /* If the call crosses section boundaries, an alignment directive could
2688 cause the PC-relative offset to later increase. */
2689 if (VALID_UJTYPE_IMM (foff) && sym_sec->output_section != sec->output_section)
2690 foff += (foff < 0 ? -max_alignment : max_alignment);
2692 /* See if this function call can be shortened. */
2693 if (!VALID_UJTYPE_IMM (foff) && !(!bfd_link_pic (link_info) && near_zero))
2696 /* Shorten the function call. */
2697 BFD_ASSERT (rel->r_offset + 8 <= sec->size);
2699 auipc = bfd_get_32 (abfd, contents + rel->r_offset);
2700 jalr = bfd_get_32 (abfd, contents + rel->r_offset + 4);
2701 rd = (jalr >> OP_SH_RD) & OP_MASK_RD;
2702 rvc = rvc && VALID_RVC_J_IMM (foff) && ARCH_SIZE == 32;
2704 if (rvc && (rd == 0 || rd == X_RA))
2706 /* Relax to C.J[AL] rd, addr. */
2707 r_type = R_RISCV_RVC_JUMP;
2708 auipc = rd == 0 ? MATCH_C_J : MATCH_C_JAL;
2711 else if (VALID_UJTYPE_IMM (foff))
2713 /* Relax to JAL rd, addr. */
2714 r_type = R_RISCV_JAL;
2715 auipc = MATCH_JAL | (rd << OP_SH_RD);
2717 else /* near_zero */
2719 /* Relax to JALR rd, x0, addr. */
2720 r_type = R_RISCV_LO12_I;
2721 auipc = MATCH_JALR | (rd << OP_SH_RD);
2724 /* Replace the R_RISCV_CALL reloc. */
2725 rel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info), r_type);
2726 /* Replace the AUIPC. */
2727 bfd_put (8 * len, abfd, auipc, contents + rel->r_offset);
2729 /* Delete unnecessary JALR. */
2731 return riscv_relax_delete_bytes (abfd, sec, rel->r_offset + len, 8 - len);
2734 /* Traverse all output sections and return the max alignment. */
2737 _bfd_riscv_get_max_alignment (asection *sec)
2739 unsigned int max_alignment_power = 0;
2742 for (o = sec->output_section->owner->sections; o != NULL; o = o->next)
2744 if (o->alignment_power > max_alignment_power)
2745 max_alignment_power = o->alignment_power;
2748 return 1 << max_alignment_power;
2751 /* Relax non-PIC global variable references. */
2754 _bfd_riscv_relax_lui (bfd *abfd,
2757 struct bfd_link_info *link_info,
2758 Elf_Internal_Rela *rel,
2760 unsigned int max_alignment,
2763 bfd_byte *contents = elf_section_data (sec)->this_hdr.contents;
2764 bfd_vma gp = riscv_global_pointer_value (link_info);
2765 int use_rvc = elf_elfheader (abfd)->e_flags & EF_RISCV_RVC;
2767 /* Mergeable symbols and code might later move out of range. */
2768 if (sym_sec->flags & (SEC_MERGE | SEC_CODE))
2771 BFD_ASSERT (rel->r_offset + 4 <= sec->size);
2773 /* Is the reference in range of x0 or gp?
2774 Valid gp range conservatively because of alignment issue. */
2775 if (VALID_ITYPE_IMM (symval)
2776 || (symval >= gp && VALID_ITYPE_IMM (symval - gp + max_alignment))
2777 || (symval < gp && VALID_ITYPE_IMM (symval - gp - max_alignment)))
2779 unsigned sym = ELFNN_R_SYM (rel->r_info);
2780 switch (ELFNN_R_TYPE (rel->r_info))
2782 case R_RISCV_LO12_I:
2783 rel->r_info = ELFNN_R_INFO (sym, R_RISCV_GPREL_I);
2786 case R_RISCV_LO12_S:
2787 rel->r_info = ELFNN_R_INFO (sym, R_RISCV_GPREL_S);
2791 /* We can delete the unnecessary LUI and reloc. */
2792 rel->r_info = ELFNN_R_INFO (0, R_RISCV_NONE);
2794 return riscv_relax_delete_bytes (abfd, sec, rel->r_offset, 4);
2801 /* Can we relax LUI to C.LUI? Alignment might move the section forward;
2802 account for this assuming page alignment at worst. */
2804 && ELFNN_R_TYPE (rel->r_info) == R_RISCV_HI20
2805 && VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (symval))
2806 && VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (symval + ELF_MAXPAGESIZE)))
2808 /* Replace LUI with C.LUI if legal (i.e., rd != x2/sp). */
2809 bfd_vma lui = bfd_get_32 (abfd, contents + rel->r_offset);
2810 if (((lui >> OP_SH_RD) & OP_MASK_RD) == X_SP)
2813 lui = (lui & (OP_MASK_RD << OP_SH_RD)) | MATCH_C_LUI;
2814 bfd_put_32 (abfd, lui, contents + rel->r_offset);
2816 /* Replace the R_RISCV_HI20 reloc. */
2817 rel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info), R_RISCV_RVC_LUI);
2820 return riscv_relax_delete_bytes (abfd, sec, rel->r_offset + 2, 2);
2826 /* Relax non-PIC TLS references. */
2829 _bfd_riscv_relax_tls_le (bfd *abfd,
2831 asection *sym_sec ATTRIBUTE_UNUSED,
2832 struct bfd_link_info *link_info,
2833 Elf_Internal_Rela *rel,
2835 unsigned int max_alignment ATTRIBUTE_UNUSED,
2838 /* See if this symbol is in range of tp. */
2839 if (RISCV_CONST_HIGH_PART (tpoff (link_info, symval)) != 0)
2842 /* We can delete the unnecessary LUI and tp add. The LO12 reloc will be
2843 made directly tp-relative. */
2844 BFD_ASSERT (rel->r_offset + 4 <= sec->size);
2845 rel->r_info = ELFNN_R_INFO (0, R_RISCV_NONE);
2848 return riscv_relax_delete_bytes (abfd, sec, rel->r_offset, 4);
2851 /* Implement R_RISCV_ALIGN by deleting excess alignment NOPs. */
2854 _bfd_riscv_relax_align (bfd *abfd, asection *sec,
2855 asection *sym_sec ATTRIBUTE_UNUSED,
2856 struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
2857 Elf_Internal_Rela *rel,
2859 unsigned int max_alignment ATTRIBUTE_UNUSED,
2860 bfd_boolean *again ATTRIBUTE_UNUSED)
2862 bfd_byte *contents = elf_section_data (sec)->this_hdr.contents;
2863 bfd_vma alignment = 1, pos;
2864 while (alignment <= rel->r_addend)
2867 symval -= rel->r_addend;
2868 bfd_vma aligned_addr = ((symval - 1) & ~(alignment - 1)) + alignment;
2869 bfd_vma nop_bytes = aligned_addr - symval;
2871 /* Once we've handled an R_RISCV_ALIGN, we can't relax anything else. */
2872 sec->sec_flg0 = TRUE;
2874 /* Make sure there are enough NOPs to actually achieve the alignment. */
2875 if (rel->r_addend < nop_bytes)
2878 /* Delete the reloc. */
2879 rel->r_info = ELFNN_R_INFO (0, R_RISCV_NONE);
2881 /* If the number of NOPs is already correct, there's nothing to do. */
2882 if (nop_bytes == rel->r_addend)
2885 /* Write as many RISC-V NOPs as we need. */
2886 for (pos = 0; pos < (nop_bytes & -4); pos += 4)
2887 bfd_put_32 (abfd, RISCV_NOP, contents + rel->r_offset + pos);
2889 /* Write a final RVC NOP if need be. */
2890 if (nop_bytes % 4 != 0)
2891 bfd_put_16 (abfd, RVC_NOP, contents + rel->r_offset + pos);
2893 /* Delete the excess bytes. */
2894 return riscv_relax_delete_bytes (abfd, sec, rel->r_offset + nop_bytes,
2895 rel->r_addend - nop_bytes);
2898 /* Relax a section. Pass 0 shortens code sequences unless disabled.
2899 Pass 1, which cannot be disabled, handles code alignment directives. */
2902 _bfd_riscv_relax_section (bfd *abfd, asection *sec,
2903 struct bfd_link_info *info,
2906 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (abfd);
2907 struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info);
2908 struct bfd_elf_section_data *data = elf_section_data (sec);
2909 Elf_Internal_Rela *relocs;
2910 bfd_boolean ret = FALSE;
2912 unsigned int max_alignment;
2916 if (bfd_link_relocatable (info)
2918 || (sec->flags & SEC_RELOC) == 0
2919 || sec->reloc_count == 0
2920 || (info->disable_target_specific_optimizations
2921 && info->relax_pass == 0))
2924 /* Read this BFD's relocs if we haven't done so already. */
2926 relocs = data->relocs;
2927 else if (!(relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
2928 info->keep_memory)))
2931 max_alignment = _bfd_riscv_get_max_alignment (sec);
2933 /* Examine and consider relaxing each reloc. */
2934 for (i = 0; i < sec->reloc_count; i++)
2937 Elf_Internal_Rela *rel = relocs + i;
2938 typeof (&_bfd_riscv_relax_call) relax_func = NULL;
2939 int type = ELFNN_R_TYPE (rel->r_info);
2942 if (info->relax_pass == 0)
2944 if (type == R_RISCV_CALL || type == R_RISCV_CALL_PLT)
2945 relax_func = _bfd_riscv_relax_call;
2946 else if (type == R_RISCV_HI20
2947 || type == R_RISCV_LO12_I
2948 || type == R_RISCV_LO12_S)
2949 relax_func = _bfd_riscv_relax_lui;
2950 else if (type == R_RISCV_TPREL_HI20 || type == R_RISCV_TPREL_ADD)
2951 relax_func = _bfd_riscv_relax_tls_le;
2953 else if (type == R_RISCV_ALIGN)
2954 relax_func = _bfd_riscv_relax_align;
2959 data->relocs = relocs;
2961 /* Read this BFD's contents if we haven't done so already. */
2962 if (!data->this_hdr.contents
2963 && !bfd_malloc_and_get_section (abfd, sec, &data->this_hdr.contents))
2966 /* Read this BFD's symbols if we haven't done so already. */
2967 if (symtab_hdr->sh_info != 0
2968 && !symtab_hdr->contents
2969 && !(symtab_hdr->contents =
2970 (unsigned char *) bfd_elf_get_elf_syms (abfd, symtab_hdr,
2971 symtab_hdr->sh_info,
2972 0, NULL, NULL, NULL)))
2975 /* Get the value of the symbol referred to by the reloc. */
2976 if (ELFNN_R_SYM (rel->r_info) < symtab_hdr->sh_info)
2978 /* A local symbol. */
2979 Elf_Internal_Sym *isym = ((Elf_Internal_Sym *) symtab_hdr->contents
2980 + ELFNN_R_SYM (rel->r_info));
2982 if (isym->st_shndx == SHN_UNDEF)
2983 sym_sec = sec, symval = sec_addr (sec) + rel->r_offset;
2986 BFD_ASSERT (isym->st_shndx < elf_numsections (abfd));
2987 sym_sec = elf_elfsections (abfd)[isym->st_shndx]->bfd_section;
2988 if (sec_addr (sym_sec) == 0)
2990 symval = sec_addr (sym_sec) + isym->st_value;
2996 struct elf_link_hash_entry *h;
2998 indx = ELFNN_R_SYM (rel->r_info) - symtab_hdr->sh_info;
2999 h = elf_sym_hashes (abfd)[indx];
3001 while (h->root.type == bfd_link_hash_indirect
3002 || h->root.type == bfd_link_hash_warning)
3003 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3005 if (h->plt.offset != MINUS_ONE)
3006 symval = sec_addr (htab->elf.splt) + h->plt.offset;
3007 else if (h->root.u.def.section->output_section == NULL
3008 || (h->root.type != bfd_link_hash_defined
3009 && h->root.type != bfd_link_hash_defweak))
3012 symval = sec_addr (h->root.u.def.section) + h->root.u.def.value;
3014 sym_sec = h->root.u.def.section;
3017 symval += rel->r_addend;
3019 if (!relax_func (abfd, sec, sym_sec, info, rel, symval,
3020 max_alignment, again))
3027 if (relocs != data->relocs)
3034 # define PRSTATUS_SIZE 0 /* FIXME */
3035 # define PRSTATUS_OFFSET_PR_CURSIG 12
3036 # define PRSTATUS_OFFSET_PR_PID 24
3037 # define PRSTATUS_OFFSET_PR_REG 72
3038 # define ELF_GREGSET_T_SIZE 128
3039 # define PRPSINFO_SIZE 128
3040 # define PRPSINFO_OFFSET_PR_PID 16
3041 # define PRPSINFO_OFFSET_PR_FNAME 32
3042 # define PRPSINFO_OFFSET_PR_PSARGS 48
3044 # define PRSTATUS_SIZE 376
3045 # define PRSTATUS_OFFSET_PR_CURSIG 12
3046 # define PRSTATUS_OFFSET_PR_PID 32
3047 # define PRSTATUS_OFFSET_PR_REG 112
3048 # define ELF_GREGSET_T_SIZE 256
3049 # define PRPSINFO_SIZE 136
3050 # define PRPSINFO_OFFSET_PR_PID 24
3051 # define PRPSINFO_OFFSET_PR_FNAME 40
3052 # define PRPSINFO_OFFSET_PR_PSARGS 56
3055 /* Support for core dump NOTE sections. */
3058 riscv_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
3060 switch (note->descsz)
3065 case PRSTATUS_SIZE: /* sizeof(struct elf_prstatus) on Linux/RISC-V. */
3067 elf_tdata (abfd)->core->signal
3068 = bfd_get_16 (abfd, note->descdata + PRSTATUS_OFFSET_PR_CURSIG);
3071 elf_tdata (abfd)->core->lwpid
3072 = bfd_get_32 (abfd, note->descdata + PRSTATUS_OFFSET_PR_PID);
3076 /* Make a ".reg/999" section. */
3077 return _bfd_elfcore_make_pseudosection (abfd, ".reg", ELF_GREGSET_T_SIZE,
3078 note->descpos + PRSTATUS_OFFSET_PR_REG);
3082 riscv_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
3084 switch (note->descsz)
3089 case PRPSINFO_SIZE: /* sizeof(struct elf_prpsinfo) on Linux/RISC-V. */
3091 elf_tdata (abfd)->core->pid
3092 = bfd_get_32 (abfd, note->descdata + PRPSINFO_OFFSET_PR_PID);
3095 elf_tdata (abfd)->core->program = _bfd_elfcore_strndup
3096 (abfd, note->descdata + PRPSINFO_OFFSET_PR_FNAME, 16);
3099 elf_tdata (abfd)->core->command = _bfd_elfcore_strndup
3100 (abfd, note->descdata + PRPSINFO_OFFSET_PR_PSARGS, 80);
3104 /* Note that for some reason, a spurious space is tacked
3105 onto the end of the args in some (at least one anyway)
3106 implementations, so strip it off if it exists. */
3109 char *command = elf_tdata (abfd)->core->command;
3110 int n = strlen (command);
3112 if (0 < n && command[n - 1] == ' ')
3113 command[n - 1] = '\0';
3120 #define TARGET_LITTLE_SYM riscv_elfNN_vec
3121 #define TARGET_LITTLE_NAME "elfNN-littleriscv"
3123 #define elf_backend_reloc_type_class riscv_reloc_type_class
3125 #define bfd_elfNN_bfd_reloc_name_lookup riscv_reloc_name_lookup
3126 #define bfd_elfNN_bfd_link_hash_table_create riscv_elf_link_hash_table_create
3127 #define bfd_elfNN_bfd_reloc_type_lookup riscv_reloc_type_lookup
3128 #define bfd_elfNN_bfd_merge_private_bfd_data \
3129 _bfd_riscv_elf_merge_private_bfd_data
3131 #define elf_backend_copy_indirect_symbol riscv_elf_copy_indirect_symbol
3132 #define elf_backend_create_dynamic_sections riscv_elf_create_dynamic_sections
3133 #define elf_backend_check_relocs riscv_elf_check_relocs
3134 #define elf_backend_adjust_dynamic_symbol riscv_elf_adjust_dynamic_symbol
3135 #define elf_backend_size_dynamic_sections riscv_elf_size_dynamic_sections
3136 #define elf_backend_relocate_section riscv_elf_relocate_section
3137 #define elf_backend_finish_dynamic_symbol riscv_elf_finish_dynamic_symbol
3138 #define elf_backend_finish_dynamic_sections riscv_elf_finish_dynamic_sections
3139 #define elf_backend_gc_mark_hook riscv_elf_gc_mark_hook
3140 #define elf_backend_gc_sweep_hook riscv_elf_gc_sweep_hook
3141 #define elf_backend_plt_sym_val riscv_elf_plt_sym_val
3142 #define elf_backend_grok_prstatus riscv_elf_grok_prstatus
3143 #define elf_backend_grok_psinfo riscv_elf_grok_psinfo
3144 #define elf_info_to_howto_rel NULL
3145 #define elf_info_to_howto riscv_info_to_howto_rela
3146 #define bfd_elfNN_bfd_relax_section _bfd_riscv_relax_section
3148 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
3150 #define elf_backend_can_gc_sections 1
3151 #define elf_backend_can_refcount 1
3152 #define elf_backend_want_got_plt 1
3153 #define elf_backend_plt_readonly 1
3154 #define elf_backend_plt_alignment 4
3155 #define elf_backend_want_plt_sym 1
3156 #define elf_backend_got_header_size (ARCH_SIZE / 8)
3157 #define elf_backend_rela_normal 1
3158 #define elf_backend_default_execstack 0
3160 #include "elfNN-target.h"