1 /* RISC-V-specific support for NN-bit ELF.
2 Copyright (C) 2011-2018 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"
35 /* Internal relocations used exclusively by the relaxation pass. */
36 #define R_RISCV_DELETE (R_RISCV_max + 1)
40 #define MINUS_ONE ((bfd_vma)0 - 1)
42 #define RISCV_ELF_LOG_WORD_BYTES (ARCH_SIZE == 32 ? 2 : 3)
44 #define RISCV_ELF_WORD_BYTES (1 << RISCV_ELF_LOG_WORD_BYTES)
46 /* The name of the dynamic interpreter. This is put in the .interp
49 #define ELF64_DYNAMIC_INTERPRETER "/lib/ld.so.1"
50 #define ELF32_DYNAMIC_INTERPRETER "/lib32/ld.so.1"
52 #define ELF_ARCH bfd_arch_riscv
53 #define ELF_TARGET_ID RISCV_ELF_DATA
54 #define ELF_MACHINE_CODE EM_RISCV
55 #define ELF_MAXPAGESIZE 0x1000
56 #define ELF_COMMONPAGESIZE 0x1000
58 /* RISC-V ELF linker hash entry. */
60 struct riscv_elf_link_hash_entry
62 struct elf_link_hash_entry elf
;
64 /* Track dynamic relocs copied for this symbol. */
65 struct elf_dyn_relocs
*dyn_relocs
;
75 #define riscv_elf_hash_entry(ent) \
76 ((struct riscv_elf_link_hash_entry *)(ent))
78 struct _bfd_riscv_elf_obj_tdata
80 struct elf_obj_tdata root
;
82 /* tls_type for each local got entry. */
83 char *local_got_tls_type
;
86 #define _bfd_riscv_elf_tdata(abfd) \
87 ((struct _bfd_riscv_elf_obj_tdata *) (abfd)->tdata.any)
89 #define _bfd_riscv_elf_local_got_tls_type(abfd) \
90 (_bfd_riscv_elf_tdata (abfd)->local_got_tls_type)
92 #define _bfd_riscv_elf_tls_type(abfd, h, symndx) \
93 (*((h) != NULL ? &riscv_elf_hash_entry (h)->tls_type \
94 : &_bfd_riscv_elf_local_got_tls_type (abfd) [symndx]))
96 #define is_riscv_elf(bfd) \
97 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
98 && elf_tdata (bfd) != NULL \
99 && elf_object_id (bfd) == RISCV_ELF_DATA)
101 #include "elf/common.h"
102 #include "elf/internal.h"
104 struct riscv_elf_link_hash_table
106 struct elf_link_hash_table elf
;
108 /* Short-cuts to get to dynamic linker sections. */
111 /* Small local sym to section mapping cache. */
112 struct sym_cache sym_cache
;
114 /* The max alignment of output sections. */
115 bfd_vma max_alignment
;
119 /* Get the RISC-V ELF linker hash table from a link_info structure. */
120 #define riscv_elf_hash_table(p) \
121 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
122 == RISCV_ELF_DATA ? ((struct riscv_elf_link_hash_table *) ((p)->hash)) : NULL)
125 riscv_info_to_howto_rela (bfd
*abfd
,
127 Elf_Internal_Rela
*dst
)
129 cache_ptr
->howto
= riscv_elf_rtype_to_howto (abfd
, ELFNN_R_TYPE (dst
->r_info
));
130 return cache_ptr
->howto
!= NULL
;
134 riscv_elf_append_rela (bfd
*abfd
, asection
*s
, Elf_Internal_Rela
*rel
)
136 const struct elf_backend_data
*bed
;
139 bed
= get_elf_backend_data (abfd
);
140 loc
= s
->contents
+ (s
->reloc_count
++ * bed
->s
->sizeof_rela
);
141 bed
->s
->swap_reloca_out (abfd
, rel
, loc
);
146 #define PLT_HEADER_INSNS 8
147 #define PLT_ENTRY_INSNS 4
148 #define PLT_HEADER_SIZE (PLT_HEADER_INSNS * 4)
149 #define PLT_ENTRY_SIZE (PLT_ENTRY_INSNS * 4)
151 #define GOT_ENTRY_SIZE RISCV_ELF_WORD_BYTES
153 #define GOTPLT_HEADER_SIZE (2 * GOT_ENTRY_SIZE)
155 #define sec_addr(sec) ((sec)->output_section->vma + (sec)->output_offset)
158 riscv_elf_got_plt_val (bfd_vma plt_index
, struct bfd_link_info
*info
)
160 return sec_addr (riscv_elf_hash_table (info
)->elf
.sgotplt
)
161 + GOTPLT_HEADER_SIZE
+ (plt_index
* GOT_ENTRY_SIZE
);
165 # define MATCH_LREG MATCH_LW
167 # define MATCH_LREG MATCH_LD
170 /* Generate a PLT header. */
173 riscv_make_plt_header (bfd_vma gotplt_addr
, bfd_vma addr
, uint32_t *entry
)
175 bfd_vma gotplt_offset_high
= RISCV_PCREL_HIGH_PART (gotplt_addr
, addr
);
176 bfd_vma gotplt_offset_low
= RISCV_PCREL_LOW_PART (gotplt_addr
, addr
);
178 /* auipc t2, %hi(.got.plt)
179 sub t1, t1, t3 # shifted .got.plt offset + hdr size + 12
180 l[w|d] t3, %lo(.got.plt)(t2) # _dl_runtime_resolve
181 addi t1, t1, -(hdr size + 12) # shifted .got.plt offset
182 addi t0, t2, %lo(.got.plt) # &.got.plt
183 srli t1, t1, log2(16/PTRSIZE) # .got.plt offset
184 l[w|d] t0, PTRSIZE(t0) # link map
187 entry
[0] = RISCV_UTYPE (AUIPC
, X_T2
, gotplt_offset_high
);
188 entry
[1] = RISCV_RTYPE (SUB
, X_T1
, X_T1
, X_T3
);
189 entry
[2] = RISCV_ITYPE (LREG
, X_T3
, X_T2
, gotplt_offset_low
);
190 entry
[3] = RISCV_ITYPE (ADDI
, X_T1
, X_T1
, -(PLT_HEADER_SIZE
+ 12));
191 entry
[4] = RISCV_ITYPE (ADDI
, X_T0
, X_T2
, gotplt_offset_low
);
192 entry
[5] = RISCV_ITYPE (SRLI
, X_T1
, X_T1
, 4 - RISCV_ELF_LOG_WORD_BYTES
);
193 entry
[6] = RISCV_ITYPE (LREG
, X_T0
, X_T0
, RISCV_ELF_WORD_BYTES
);
194 entry
[7] = RISCV_ITYPE (JALR
, 0, X_T3
, 0);
197 /* Generate a PLT entry. */
200 riscv_make_plt_entry (bfd_vma got
, bfd_vma addr
, uint32_t *entry
)
202 /* auipc t3, %hi(.got.plt entry)
203 l[w|d] t3, %lo(.got.plt entry)(t3)
207 entry
[0] = RISCV_UTYPE (AUIPC
, X_T3
, RISCV_PCREL_HIGH_PART (got
, addr
));
208 entry
[1] = RISCV_ITYPE (LREG
, X_T3
, X_T3
, RISCV_PCREL_LOW_PART (got
, addr
));
209 entry
[2] = RISCV_ITYPE (JALR
, X_T1
, X_T3
, 0);
210 entry
[3] = RISCV_NOP
;
213 /* Create an entry in an RISC-V ELF linker hash table. */
215 static struct bfd_hash_entry
*
216 link_hash_newfunc (struct bfd_hash_entry
*entry
,
217 struct bfd_hash_table
*table
, const char *string
)
219 /* Allocate the structure if it has not already been allocated by a
224 bfd_hash_allocate (table
,
225 sizeof (struct riscv_elf_link_hash_entry
));
230 /* Call the allocation method of the superclass. */
231 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
234 struct riscv_elf_link_hash_entry
*eh
;
236 eh
= (struct riscv_elf_link_hash_entry
*) entry
;
237 eh
->dyn_relocs
= NULL
;
238 eh
->tls_type
= GOT_UNKNOWN
;
244 /* Create a RISC-V ELF linker hash table. */
246 static struct bfd_link_hash_table
*
247 riscv_elf_link_hash_table_create (bfd
*abfd
)
249 struct riscv_elf_link_hash_table
*ret
;
250 bfd_size_type amt
= sizeof (struct riscv_elf_link_hash_table
);
252 ret
= (struct riscv_elf_link_hash_table
*) bfd_zmalloc (amt
);
256 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
, link_hash_newfunc
,
257 sizeof (struct riscv_elf_link_hash_entry
),
264 ret
->max_alignment
= (bfd_vma
) -1;
265 return &ret
->elf
.root
;
268 /* Create the .got section. */
271 riscv_elf_create_got_section (bfd
*abfd
, struct bfd_link_info
*info
)
275 struct elf_link_hash_entry
*h
;
276 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
277 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
279 /* This function may be called more than once. */
280 if (htab
->sgot
!= NULL
)
283 flags
= bed
->dynamic_sec_flags
;
285 s
= bfd_make_section_anyway_with_flags (abfd
,
286 (bed
->rela_plts_and_copies_p
287 ? ".rela.got" : ".rel.got"),
288 (bed
->dynamic_sec_flags
291 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
295 s
= s_got
= bfd_make_section_anyway_with_flags (abfd
, ".got", flags
);
297 || !bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
301 /* The first bit of the global offset table is the header. */
302 s
->size
+= bed
->got_header_size
;
304 if (bed
->want_got_plt
)
306 s
= bfd_make_section_anyway_with_flags (abfd
, ".got.plt", flags
);
308 || !bfd_set_section_alignment (abfd
, s
,
309 bed
->s
->log_file_align
))
313 /* Reserve room for the header. */
314 s
->size
+= GOTPLT_HEADER_SIZE
;
317 if (bed
->want_got_sym
)
319 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
320 section. We don't do this in the linker script because we don't want
321 to define the symbol if we are not creating a global offset
323 h
= _bfd_elf_define_linkage_sym (abfd
, info
, s_got
,
324 "_GLOBAL_OFFSET_TABLE_");
325 elf_hash_table (info
)->hgot
= h
;
333 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
334 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
338 riscv_elf_create_dynamic_sections (bfd
*dynobj
,
339 struct bfd_link_info
*info
)
341 struct riscv_elf_link_hash_table
*htab
;
343 htab
= riscv_elf_hash_table (info
);
344 BFD_ASSERT (htab
!= NULL
);
346 if (!riscv_elf_create_got_section (dynobj
, info
))
349 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
352 if (!bfd_link_pic (info
))
355 bfd_make_section_anyway_with_flags (dynobj
, ".tdata.dyn",
356 SEC_ALLOC
| SEC_THREAD_LOCAL
);
359 if (!htab
->elf
.splt
|| !htab
->elf
.srelplt
|| !htab
->elf
.sdynbss
360 || (!bfd_link_pic (info
) && (!htab
->elf
.srelbss
|| !htab
->sdyntdata
)))
366 /* Copy the extra info we tack onto an elf_link_hash_entry. */
369 riscv_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
370 struct elf_link_hash_entry
*dir
,
371 struct elf_link_hash_entry
*ind
)
373 struct riscv_elf_link_hash_entry
*edir
, *eind
;
375 edir
= (struct riscv_elf_link_hash_entry
*) dir
;
376 eind
= (struct riscv_elf_link_hash_entry
*) ind
;
378 if (eind
->dyn_relocs
!= NULL
)
380 if (edir
->dyn_relocs
!= NULL
)
382 struct elf_dyn_relocs
**pp
;
383 struct elf_dyn_relocs
*p
;
385 /* Add reloc counts against the indirect sym to the direct sym
386 list. Merge any entries against the same section. */
387 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
389 struct elf_dyn_relocs
*q
;
391 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
392 if (q
->sec
== p
->sec
)
394 q
->pc_count
+= p
->pc_count
;
395 q
->count
+= p
->count
;
402 *pp
= edir
->dyn_relocs
;
405 edir
->dyn_relocs
= eind
->dyn_relocs
;
406 eind
->dyn_relocs
= NULL
;
409 if (ind
->root
.type
== bfd_link_hash_indirect
410 && dir
->got
.refcount
<= 0)
412 edir
->tls_type
= eind
->tls_type
;
413 eind
->tls_type
= GOT_UNKNOWN
;
415 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
419 riscv_elf_record_tls_type (bfd
*abfd
, struct elf_link_hash_entry
*h
,
420 unsigned long symndx
, char tls_type
)
422 char *new_tls_type
= &_bfd_riscv_elf_tls_type (abfd
, h
, symndx
);
424 *new_tls_type
|= tls_type
;
425 if ((*new_tls_type
& GOT_NORMAL
) && (*new_tls_type
& ~GOT_NORMAL
))
427 (*_bfd_error_handler
)
428 (_("%pB: `%s' accessed both as normal and thread local symbol"),
429 abfd
, h
? h
->root
.root
.string
: "<local>");
436 riscv_elf_record_got_reference (bfd
*abfd
, struct bfd_link_info
*info
,
437 struct elf_link_hash_entry
*h
, long symndx
)
439 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
440 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
442 if (htab
->elf
.sgot
== NULL
)
444 if (!riscv_elf_create_got_section (htab
->elf
.dynobj
, info
))
450 h
->got
.refcount
+= 1;
454 /* This is a global offset table entry for a local symbol. */
455 if (elf_local_got_refcounts (abfd
) == NULL
)
457 bfd_size_type size
= symtab_hdr
->sh_info
* (sizeof (bfd_vma
) + 1);
458 if (!(elf_local_got_refcounts (abfd
) = bfd_zalloc (abfd
, size
)))
460 _bfd_riscv_elf_local_got_tls_type (abfd
)
461 = (char *) (elf_local_got_refcounts (abfd
) + symtab_hdr
->sh_info
);
463 elf_local_got_refcounts (abfd
) [symndx
] += 1;
469 bad_static_reloc (bfd
*abfd
, unsigned r_type
, struct elf_link_hash_entry
*h
)
471 reloc_howto_type
* r
= riscv_elf_rtype_to_howto (abfd
, r_type
);
473 (*_bfd_error_handler
)
474 (_("%pB: relocation %s against `%s' can not be used when making a shared "
475 "object; recompile with -fPIC"),
476 abfd
, r
? r
->name
: _("<unknown>"),
477 h
!= NULL
? h
->root
.root
.string
: "a local symbol");
478 bfd_set_error (bfd_error_bad_value
);
481 /* Look through the relocs for a section during the first phase, and
482 allocate space in the global offset table or procedure linkage
486 riscv_elf_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
487 asection
*sec
, const Elf_Internal_Rela
*relocs
)
489 struct riscv_elf_link_hash_table
*htab
;
490 Elf_Internal_Shdr
*symtab_hdr
;
491 struct elf_link_hash_entry
**sym_hashes
;
492 const Elf_Internal_Rela
*rel
;
493 asection
*sreloc
= NULL
;
495 if (bfd_link_relocatable (info
))
498 htab
= riscv_elf_hash_table (info
);
499 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
500 sym_hashes
= elf_sym_hashes (abfd
);
502 if (htab
->elf
.dynobj
== NULL
)
503 htab
->elf
.dynobj
= abfd
;
505 for (rel
= relocs
; rel
< relocs
+ sec
->reloc_count
; rel
++)
508 unsigned int r_symndx
;
509 struct elf_link_hash_entry
*h
;
511 r_symndx
= ELFNN_R_SYM (rel
->r_info
);
512 r_type
= ELFNN_R_TYPE (rel
->r_info
);
514 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
516 (*_bfd_error_handler
) (_("%pB: bad symbol index: %d"),
521 if (r_symndx
< symtab_hdr
->sh_info
)
525 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
526 while (h
->root
.type
== bfd_link_hash_indirect
527 || h
->root
.type
== bfd_link_hash_warning
)
528 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
533 case R_RISCV_TLS_GD_HI20
:
534 if (!riscv_elf_record_got_reference (abfd
, info
, h
, r_symndx
)
535 || !riscv_elf_record_tls_type (abfd
, h
, r_symndx
, GOT_TLS_GD
))
539 case R_RISCV_TLS_GOT_HI20
:
540 if (bfd_link_pic (info
))
541 info
->flags
|= DF_STATIC_TLS
;
542 if (!riscv_elf_record_got_reference (abfd
, info
, h
, r_symndx
)
543 || !riscv_elf_record_tls_type (abfd
, h
, r_symndx
, GOT_TLS_IE
))
547 case R_RISCV_GOT_HI20
:
548 if (!riscv_elf_record_got_reference (abfd
, info
, h
, r_symndx
)
549 || !riscv_elf_record_tls_type (abfd
, h
, r_symndx
, GOT_NORMAL
))
553 case R_RISCV_CALL_PLT
:
554 /* This symbol requires a procedure linkage table entry. We
555 actually build the entry in adjust_dynamic_symbol,
556 because this might be a case of linking PIC code without
557 linking in any dynamic objects, in which case we don't
558 need to generate a procedure linkage table after all. */
563 h
->plt
.refcount
+= 1;
570 case R_RISCV_RVC_BRANCH
:
571 case R_RISCV_RVC_JUMP
:
572 case R_RISCV_PCREL_HI20
:
573 /* In shared libraries, these relocs are known to bind locally. */
574 if (bfd_link_pic (info
))
578 case R_RISCV_TPREL_HI20
:
579 if (!bfd_link_executable (info
))
580 return bad_static_reloc (abfd
, r_type
, h
);
582 riscv_elf_record_tls_type (abfd
, h
, r_symndx
, GOT_TLS_LE
);
586 if (bfd_link_pic (info
))
587 return bad_static_reloc (abfd
, r_type
, h
);
591 case R_RISCV_JUMP_SLOT
:
592 case R_RISCV_RELATIVE
:
598 /* This reloc might not bind locally. */
602 if (h
!= NULL
&& !bfd_link_pic (info
))
604 /* We may need a .plt entry if the function this reloc
605 refers to is in a shared lib. */
606 h
->plt
.refcount
+= 1;
609 /* If we are creating a shared library, and this is a reloc
610 against a global symbol, or a non PC relative reloc
611 against a local symbol, then we need to copy the reloc
612 into the shared library. However, if we are linking with
613 -Bsymbolic, we do not need to copy a reloc against a
614 global symbol which is defined in an object we are
615 including in the link (i.e., DEF_REGULAR is set). At
616 this point we have not seen all the input files, so it is
617 possible that DEF_REGULAR is not set now but will be set
618 later (it is never cleared). In case of a weak definition,
619 DEF_REGULAR may be cleared later by a strong definition in
620 a shared library. We account for that possibility below by
621 storing information in the relocs_copied field of the hash
622 table entry. A similar situation occurs when creating
623 shared libraries and symbol visibility changes render the
626 If on the other hand, we are creating an executable, we
627 may need to keep relocations for symbols satisfied by a
628 dynamic library if we manage to avoid copy relocs for the
630 reloc_howto_type
* r
= riscv_elf_rtype_to_howto (abfd
, r_type
);
632 if ((bfd_link_pic (info
)
633 && (sec
->flags
& SEC_ALLOC
) != 0
634 && ((r
!= NULL
&& ! r
->pc_relative
)
637 || h
->root
.type
== bfd_link_hash_defweak
638 || !h
->def_regular
))))
639 || (!bfd_link_pic (info
)
640 && (sec
->flags
& SEC_ALLOC
) != 0
642 && (h
->root
.type
== bfd_link_hash_defweak
643 || !h
->def_regular
)))
645 struct elf_dyn_relocs
*p
;
646 struct elf_dyn_relocs
**head
;
648 /* When creating a shared object, we must copy these
649 relocs into the output file. We create a reloc
650 section in dynobj and make room for the reloc. */
653 sreloc
= _bfd_elf_make_dynamic_reloc_section
654 (sec
, htab
->elf
.dynobj
, RISCV_ELF_LOG_WORD_BYTES
,
655 abfd
, /*rela?*/ TRUE
);
661 /* If this is a global symbol, we count the number of
662 relocations we need for this symbol. */
664 head
= &((struct riscv_elf_link_hash_entry
*) h
)->dyn_relocs
;
667 /* Track dynamic relocs needed for local syms too.
668 We really need local syms available to do this
673 Elf_Internal_Sym
*isym
;
675 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
680 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
684 vpp
= &elf_section_data (s
)->local_dynrel
;
685 head
= (struct elf_dyn_relocs
**) vpp
;
689 if (p
== NULL
|| p
->sec
!= sec
)
691 bfd_size_type amt
= sizeof *p
;
692 p
= ((struct elf_dyn_relocs
*)
693 bfd_alloc (htab
->elf
.dynobj
, amt
));
704 p
->pc_count
+= r
== NULL
? 0 : r
->pc_relative
;
709 case R_RISCV_GNU_VTINHERIT
:
710 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
714 case R_RISCV_GNU_VTENTRY
:
715 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
728 riscv_elf_gc_mark_hook (asection
*sec
,
729 struct bfd_link_info
*info
,
730 Elf_Internal_Rela
*rel
,
731 struct elf_link_hash_entry
*h
,
732 Elf_Internal_Sym
*sym
)
735 switch (ELFNN_R_TYPE (rel
->r_info
))
737 case R_RISCV_GNU_VTINHERIT
:
738 case R_RISCV_GNU_VTENTRY
:
742 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
745 /* Find dynamic relocs for H that apply to read-only sections. */
748 readonly_dynrelocs (struct elf_link_hash_entry
*h
)
750 struct elf_dyn_relocs
*p
;
752 for (p
= riscv_elf_hash_entry (h
)->dyn_relocs
; p
!= NULL
; p
= p
->next
)
754 asection
*s
= p
->sec
->output_section
;
756 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
762 /* Adjust a symbol defined by a dynamic object and referenced by a
763 regular object. The current definition is in some section of the
764 dynamic object, but we're not including those sections. We have to
765 change the definition to something the rest of the link can
769 riscv_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
770 struct elf_link_hash_entry
*h
)
772 struct riscv_elf_link_hash_table
*htab
;
773 struct riscv_elf_link_hash_entry
* eh
;
777 htab
= riscv_elf_hash_table (info
);
778 BFD_ASSERT (htab
!= NULL
);
780 dynobj
= htab
->elf
.dynobj
;
782 /* Make sure we know what is going on here. */
783 BFD_ASSERT (dynobj
!= NULL
785 || h
->type
== STT_GNU_IFUNC
789 && !h
->def_regular
)));
791 /* If this is a function, put it in the procedure linkage table. We
792 will fill in the contents of the procedure linkage table later
793 (although we could actually do it here). */
794 if (h
->type
== STT_FUNC
|| h
->type
== STT_GNU_IFUNC
|| h
->needs_plt
)
796 if (h
->plt
.refcount
<= 0
797 || SYMBOL_CALLS_LOCAL (info
, h
)
798 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
799 && h
->root
.type
== bfd_link_hash_undefweak
))
801 /* This case can occur if we saw a R_RISCV_CALL_PLT reloc in an
802 input file, but the symbol was never referred to by a dynamic
803 object, or if all references were garbage collected. In such
804 a case, we don't actually need to build a PLT entry. */
805 h
->plt
.offset
= (bfd_vma
) -1;
812 h
->plt
.offset
= (bfd_vma
) -1;
814 /* If this is a weak symbol, and there is a real definition, the
815 processor independent code will have arranged for us to see the
816 real definition first, and we can just use the same value. */
819 struct elf_link_hash_entry
*def
= weakdef (h
);
820 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
821 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
822 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
826 /* This is a reference to a symbol defined by a dynamic object which
827 is not a function. */
829 /* If we are creating a shared library, we must presume that the
830 only references to the symbol are via the global offset table.
831 For such cases we need not do anything here; the relocations will
832 be handled correctly by relocate_section. */
833 if (bfd_link_pic (info
))
836 /* If there are no references to this symbol that do not use the
837 GOT, we don't need to generate a copy reloc. */
841 /* If -z nocopyreloc was given, we won't generate them either. */
842 if (info
->nocopyreloc
)
848 /* If we don't find any dynamic relocs in read-only sections, then
849 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
850 if (!readonly_dynrelocs (h
))
856 /* We must allocate the symbol in our .dynbss section, which will
857 become part of the .bss section of the executable. There will be
858 an entry for this symbol in the .dynsym section. The dynamic
859 object will contain position independent code, so all references
860 from the dynamic object to this symbol will go through the global
861 offset table. The dynamic linker will use the .dynsym entry to
862 determine the address it must put in the global offset table, so
863 both the dynamic object and the regular object will refer to the
864 same memory location for the variable. */
866 /* We must generate a R_RISCV_COPY reloc to tell the dynamic linker
867 to copy the initial value out of the dynamic object and into the
868 runtime process image. We need to remember the offset into the
869 .rel.bss section we are going to use. */
870 eh
= (struct riscv_elf_link_hash_entry
*) h
;
871 if (eh
->tls_type
& ~GOT_NORMAL
)
874 srel
= htab
->elf
.srelbss
;
876 else if ((h
->root
.u
.def
.section
->flags
& SEC_READONLY
) != 0)
878 s
= htab
->elf
.sdynrelro
;
879 srel
= htab
->elf
.sreldynrelro
;
883 s
= htab
->elf
.sdynbss
;
884 srel
= htab
->elf
.srelbss
;
886 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
888 srel
->size
+= sizeof (ElfNN_External_Rela
);
892 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
895 /* Allocate space in .plt, .got and associated reloc sections for
899 allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
901 struct bfd_link_info
*info
;
902 struct riscv_elf_link_hash_table
*htab
;
903 struct riscv_elf_link_hash_entry
*eh
;
904 struct elf_dyn_relocs
*p
;
906 if (h
->root
.type
== bfd_link_hash_indirect
)
909 info
= (struct bfd_link_info
*) inf
;
910 htab
= riscv_elf_hash_table (info
);
911 BFD_ASSERT (htab
!= NULL
);
913 if (htab
->elf
.dynamic_sections_created
914 && h
->plt
.refcount
> 0)
916 /* Make sure this symbol is output as a dynamic symbol.
917 Undefined weak syms won't yet be marked as dynamic. */
921 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
925 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info
), h
))
927 asection
*s
= htab
->elf
.splt
;
930 s
->size
= PLT_HEADER_SIZE
;
932 h
->plt
.offset
= s
->size
;
934 /* Make room for this entry. */
935 s
->size
+= PLT_ENTRY_SIZE
;
937 /* We also need to make an entry in the .got.plt section. */
938 htab
->elf
.sgotplt
->size
+= GOT_ENTRY_SIZE
;
940 /* We also need to make an entry in the .rela.plt section. */
941 htab
->elf
.srelplt
->size
+= sizeof (ElfNN_External_Rela
);
943 /* If this symbol is not defined in a regular file, and we are
944 not generating a shared library, then set the symbol to this
945 location in the .plt. This is required to make function
946 pointers compare as equal between the normal executable and
947 the shared library. */
948 if (! bfd_link_pic (info
)
951 h
->root
.u
.def
.section
= s
;
952 h
->root
.u
.def
.value
= h
->plt
.offset
;
957 h
->plt
.offset
= (bfd_vma
) -1;
963 h
->plt
.offset
= (bfd_vma
) -1;
967 if (h
->got
.refcount
> 0)
971 int tls_type
= riscv_elf_hash_entry (h
)->tls_type
;
973 /* Make sure this symbol is output as a dynamic symbol.
974 Undefined weak syms won't yet be marked as dynamic. */
978 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
983 h
->got
.offset
= s
->size
;
984 dyn
= htab
->elf
.dynamic_sections_created
;
985 if (tls_type
& (GOT_TLS_GD
| GOT_TLS_IE
))
987 /* TLS_GD needs two dynamic relocs and two GOT slots. */
988 if (tls_type
& GOT_TLS_GD
)
990 s
->size
+= 2 * RISCV_ELF_WORD_BYTES
;
991 htab
->elf
.srelgot
->size
+= 2 * sizeof (ElfNN_External_Rela
);
994 /* TLS_IE needs one dynamic reloc and one GOT slot. */
995 if (tls_type
& GOT_TLS_IE
)
997 s
->size
+= RISCV_ELF_WORD_BYTES
;
998 htab
->elf
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
1003 s
->size
+= RISCV_ELF_WORD_BYTES
;
1004 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, bfd_link_pic (info
), h
))
1005 htab
->elf
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
1009 h
->got
.offset
= (bfd_vma
) -1;
1011 eh
= (struct riscv_elf_link_hash_entry
*) h
;
1012 if (eh
->dyn_relocs
== NULL
)
1015 /* In the shared -Bsymbolic case, discard space allocated for
1016 dynamic pc-relative relocs against symbols which turn out to be
1017 defined in regular objects. For the normal shared case, discard
1018 space for pc-relative relocs that have become local due to symbol
1019 visibility changes. */
1021 if (bfd_link_pic (info
))
1023 if (SYMBOL_CALLS_LOCAL (info
, h
))
1025 struct elf_dyn_relocs
**pp
;
1027 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
1029 p
->count
-= p
->pc_count
;
1038 /* Also discard relocs on undefined weak syms with non-default
1040 if (eh
->dyn_relocs
!= NULL
1041 && h
->root
.type
== bfd_link_hash_undefweak
)
1043 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
1044 eh
->dyn_relocs
= NULL
;
1046 /* Make sure undefined weak symbols are output as a dynamic
1048 else if (h
->dynindx
== -1
1049 && !h
->forced_local
)
1051 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1058 /* For the non-shared case, discard space for relocs against
1059 symbols which turn out to need copy relocs or are not
1065 || (htab
->elf
.dynamic_sections_created
1066 && (h
->root
.type
== bfd_link_hash_undefweak
1067 || h
->root
.type
== bfd_link_hash_undefined
))))
1069 /* Make sure this symbol is output as a dynamic symbol.
1070 Undefined weak syms won't yet be marked as dynamic. */
1071 if (h
->dynindx
== -1
1072 && !h
->forced_local
)
1074 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1078 /* If that succeeded, we know we'll be keeping all the
1080 if (h
->dynindx
!= -1)
1084 eh
->dyn_relocs
= NULL
;
1089 /* Finally, allocate space. */
1090 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1092 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
1093 sreloc
->size
+= p
->count
* sizeof (ElfNN_External_Rela
);
1099 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
1100 read-only sections. */
1103 maybe_set_textrel (struct elf_link_hash_entry
*h
, void *info_p
)
1107 if (h
->root
.type
== bfd_link_hash_indirect
)
1110 sec
= readonly_dynrelocs (h
);
1113 struct bfd_link_info
*info
= (struct bfd_link_info
*) info_p
;
1115 info
->flags
|= DF_TEXTREL
;
1116 info
->callbacks
->minfo
1117 (_("%pB: dynamic relocation against `%pT' in read-only section `%pA'\n"),
1118 sec
->owner
, h
->root
.root
.string
, sec
);
1120 /* Not an error, just cut short the traversal. */
1127 riscv_elf_size_dynamic_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
1129 struct riscv_elf_link_hash_table
*htab
;
1134 htab
= riscv_elf_hash_table (info
);
1135 BFD_ASSERT (htab
!= NULL
);
1136 dynobj
= htab
->elf
.dynobj
;
1137 BFD_ASSERT (dynobj
!= NULL
);
1139 if (elf_hash_table (info
)->dynamic_sections_created
)
1141 /* Set the contents of the .interp section to the interpreter. */
1142 if (bfd_link_executable (info
) && !info
->nointerp
)
1144 s
= bfd_get_linker_section (dynobj
, ".interp");
1145 BFD_ASSERT (s
!= NULL
);
1146 s
->size
= strlen (ELFNN_DYNAMIC_INTERPRETER
) + 1;
1147 s
->contents
= (unsigned char *) ELFNN_DYNAMIC_INTERPRETER
;
1151 /* Set up .got offsets for local syms, and space for local dynamic
1153 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
1155 bfd_signed_vma
*local_got
;
1156 bfd_signed_vma
*end_local_got
;
1157 char *local_tls_type
;
1158 bfd_size_type locsymcount
;
1159 Elf_Internal_Shdr
*symtab_hdr
;
1162 if (! is_riscv_elf (ibfd
))
1165 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
1167 struct elf_dyn_relocs
*p
;
1169 for (p
= elf_section_data (s
)->local_dynrel
; p
!= NULL
; p
= p
->next
)
1171 if (!bfd_is_abs_section (p
->sec
)
1172 && bfd_is_abs_section (p
->sec
->output_section
))
1174 /* Input section has been discarded, either because
1175 it is a copy of a linkonce section or due to
1176 linker script /DISCARD/, so we'll be discarding
1179 else if (p
->count
!= 0)
1181 srel
= elf_section_data (p
->sec
)->sreloc
;
1182 srel
->size
+= p
->count
* sizeof (ElfNN_External_Rela
);
1183 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
1184 info
->flags
|= DF_TEXTREL
;
1189 local_got
= elf_local_got_refcounts (ibfd
);
1193 symtab_hdr
= &elf_symtab_hdr (ibfd
);
1194 locsymcount
= symtab_hdr
->sh_info
;
1195 end_local_got
= local_got
+ locsymcount
;
1196 local_tls_type
= _bfd_riscv_elf_local_got_tls_type (ibfd
);
1198 srel
= htab
->elf
.srelgot
;
1199 for (; local_got
< end_local_got
; ++local_got
, ++local_tls_type
)
1203 *local_got
= s
->size
;
1204 s
->size
+= RISCV_ELF_WORD_BYTES
;
1205 if (*local_tls_type
& GOT_TLS_GD
)
1206 s
->size
+= RISCV_ELF_WORD_BYTES
;
1207 if (bfd_link_pic (info
)
1208 || (*local_tls_type
& (GOT_TLS_GD
| GOT_TLS_IE
)))
1209 srel
->size
+= sizeof (ElfNN_External_Rela
);
1212 *local_got
= (bfd_vma
) -1;
1216 /* Allocate global sym .plt and .got entries, and space for global
1217 sym dynamic relocs. */
1218 elf_link_hash_traverse (&htab
->elf
, allocate_dynrelocs
, info
);
1220 if (htab
->elf
.sgotplt
)
1222 struct elf_link_hash_entry
*got
;
1223 got
= elf_link_hash_lookup (elf_hash_table (info
),
1224 "_GLOBAL_OFFSET_TABLE_",
1225 FALSE
, FALSE
, FALSE
);
1227 /* Don't allocate .got.plt section if there are no GOT nor PLT
1228 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
1230 || !got
->ref_regular_nonweak
)
1231 && (htab
->elf
.sgotplt
->size
== GOTPLT_HEADER_SIZE
)
1232 && (htab
->elf
.splt
== NULL
1233 || htab
->elf
.splt
->size
== 0)
1234 && (htab
->elf
.sgot
== NULL
1235 || (htab
->elf
.sgot
->size
1236 == get_elf_backend_data (output_bfd
)->got_header_size
)))
1237 htab
->elf
.sgotplt
->size
= 0;
1240 /* The check_relocs and adjust_dynamic_symbol entry points have
1241 determined the sizes of the various dynamic sections. Allocate
1243 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1245 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1248 if (s
== htab
->elf
.splt
1249 || s
== htab
->elf
.sgot
1250 || s
== htab
->elf
.sgotplt
1251 || s
== htab
->elf
.sdynbss
1252 || s
== htab
->elf
.sdynrelro
)
1254 /* Strip this section if we don't need it; see the
1257 else if (strncmp (s
->name
, ".rela", 5) == 0)
1261 /* We use the reloc_count field as a counter if we need
1262 to copy relocs into the output file. */
1268 /* It's not one of our sections. */
1274 /* If we don't need this section, strip it from the
1275 output file. This is mostly to handle .rela.bss and
1276 .rela.plt. We must create both sections in
1277 create_dynamic_sections, because they must be created
1278 before the linker maps input sections to output
1279 sections. The linker does that before
1280 adjust_dynamic_symbol is called, and it is that
1281 function which decides whether anything needs to go
1282 into these sections. */
1283 s
->flags
|= SEC_EXCLUDE
;
1287 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
1290 /* Allocate memory for the section contents. Zero the memory
1291 for the benefit of .rela.plt, which has 4 unused entries
1292 at the beginning, and we don't want garbage. */
1293 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
1294 if (s
->contents
== NULL
)
1298 if (elf_hash_table (info
)->dynamic_sections_created
)
1300 /* Add some entries to the .dynamic section. We fill in the
1301 values later, in riscv_elf_finish_dynamic_sections, but we
1302 must add the entries now so that we get the correct size for
1303 the .dynamic section. The DT_DEBUG entry is filled in by the
1304 dynamic linker and used by the debugger. */
1305 #define add_dynamic_entry(TAG, VAL) \
1306 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1308 if (bfd_link_executable (info
))
1310 if (!add_dynamic_entry (DT_DEBUG
, 0))
1314 if (htab
->elf
.srelplt
->size
!= 0)
1316 if (!add_dynamic_entry (DT_PLTGOT
, 0)
1317 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
1318 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
1319 || !add_dynamic_entry (DT_JMPREL
, 0))
1323 if (!add_dynamic_entry (DT_RELA
, 0)
1324 || !add_dynamic_entry (DT_RELASZ
, 0)
1325 || !add_dynamic_entry (DT_RELAENT
, sizeof (ElfNN_External_Rela
)))
1328 /* If any dynamic relocs apply to a read-only section,
1329 then we need a DT_TEXTREL entry. */
1330 if ((info
->flags
& DF_TEXTREL
) == 0)
1331 elf_link_hash_traverse (&htab
->elf
, maybe_set_textrel
, info
);
1333 if (info
->flags
& DF_TEXTREL
)
1335 if (!add_dynamic_entry (DT_TEXTREL
, 0))
1339 #undef add_dynamic_entry
1345 #define DTP_OFFSET 0x800
1347 /* Return the relocation value for a TLS dtp-relative reloc. */
1350 dtpoff (struct bfd_link_info
*info
, bfd_vma address
)
1352 /* If tls_sec is NULL, we should have signalled an error already. */
1353 if (elf_hash_table (info
)->tls_sec
== NULL
)
1355 return address
- elf_hash_table (info
)->tls_sec
->vma
- DTP_OFFSET
;
1358 /* Return the relocation value for a static TLS tp-relative relocation. */
1361 tpoff (struct bfd_link_info
*info
, bfd_vma address
)
1363 /* If tls_sec is NULL, we should have signalled an error already. */
1364 if (elf_hash_table (info
)->tls_sec
== NULL
)
1366 return address
- elf_hash_table (info
)->tls_sec
->vma
- TP_OFFSET
;
1369 /* Return the global pointer's value, or 0 if it is not in use. */
1372 riscv_global_pointer_value (struct bfd_link_info
*info
)
1374 struct bfd_link_hash_entry
*h
;
1376 h
= bfd_link_hash_lookup (info
->hash
, RISCV_GP_SYMBOL
, FALSE
, FALSE
, TRUE
);
1377 if (h
== NULL
|| h
->type
!= bfd_link_hash_defined
)
1380 return h
->u
.def
.value
+ sec_addr (h
->u
.def
.section
);
1383 /* Emplace a static relocation. */
1385 static bfd_reloc_status_type
1386 perform_relocation (const reloc_howto_type
*howto
,
1387 const Elf_Internal_Rela
*rel
,
1389 asection
*input_section
,
1393 if (howto
->pc_relative
)
1394 value
-= sec_addr (input_section
) + rel
->r_offset
;
1395 value
+= rel
->r_addend
;
1397 switch (ELFNN_R_TYPE (rel
->r_info
))
1400 case R_RISCV_TPREL_HI20
:
1401 case R_RISCV_PCREL_HI20
:
1402 case R_RISCV_GOT_HI20
:
1403 case R_RISCV_TLS_GOT_HI20
:
1404 case R_RISCV_TLS_GD_HI20
:
1405 if (ARCH_SIZE
> 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (value
)))
1406 return bfd_reloc_overflow
;
1407 value
= ENCODE_UTYPE_IMM (RISCV_CONST_HIGH_PART (value
));
1410 case R_RISCV_LO12_I
:
1411 case R_RISCV_GPREL_I
:
1412 case R_RISCV_TPREL_LO12_I
:
1413 case R_RISCV_TPREL_I
:
1414 case R_RISCV_PCREL_LO12_I
:
1415 value
= ENCODE_ITYPE_IMM (value
);
1418 case R_RISCV_LO12_S
:
1419 case R_RISCV_GPREL_S
:
1420 case R_RISCV_TPREL_LO12_S
:
1421 case R_RISCV_TPREL_S
:
1422 case R_RISCV_PCREL_LO12_S
:
1423 value
= ENCODE_STYPE_IMM (value
);
1427 case R_RISCV_CALL_PLT
:
1428 if (ARCH_SIZE
> 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (value
)))
1429 return bfd_reloc_overflow
;
1430 value
= ENCODE_UTYPE_IMM (RISCV_CONST_HIGH_PART (value
))
1431 | (ENCODE_ITYPE_IMM (value
) << 32);
1435 if (!VALID_UJTYPE_IMM (value
))
1436 return bfd_reloc_overflow
;
1437 value
= ENCODE_UJTYPE_IMM (value
);
1440 case R_RISCV_BRANCH
:
1441 if (!VALID_SBTYPE_IMM (value
))
1442 return bfd_reloc_overflow
;
1443 value
= ENCODE_SBTYPE_IMM (value
);
1446 case R_RISCV_RVC_BRANCH
:
1447 if (!VALID_RVC_B_IMM (value
))
1448 return bfd_reloc_overflow
;
1449 value
= ENCODE_RVC_B_IMM (value
);
1452 case R_RISCV_RVC_JUMP
:
1453 if (!VALID_RVC_J_IMM (value
))
1454 return bfd_reloc_overflow
;
1455 value
= ENCODE_RVC_J_IMM (value
);
1458 case R_RISCV_RVC_LUI
:
1459 if (!VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (value
)))
1460 return bfd_reloc_overflow
;
1461 value
= ENCODE_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (value
));
1479 case R_RISCV_32_PCREL
:
1480 case R_RISCV_TLS_DTPREL32
:
1481 case R_RISCV_TLS_DTPREL64
:
1484 case R_RISCV_DELETE
:
1485 return bfd_reloc_ok
;
1488 return bfd_reloc_notsupported
;
1491 bfd_vma word
= bfd_get (howto
->bitsize
, input_bfd
, contents
+ rel
->r_offset
);
1492 word
= (word
& ~howto
->dst_mask
) | (value
& howto
->dst_mask
);
1493 bfd_put (howto
->bitsize
, input_bfd
, word
, contents
+ rel
->r_offset
);
1495 return bfd_reloc_ok
;
1498 /* Remember all PC-relative high-part relocs we've encountered to help us
1499 later resolve the corresponding low-part relocs. */
1505 } riscv_pcrel_hi_reloc
;
1507 typedef struct riscv_pcrel_lo_reloc
1509 asection
* input_section
;
1510 struct bfd_link_info
* info
;
1511 reloc_howto_type
* howto
;
1512 const Elf_Internal_Rela
* reloc
;
1515 bfd_byte
* contents
;
1516 struct riscv_pcrel_lo_reloc
* next
;
1517 } riscv_pcrel_lo_reloc
;
1522 riscv_pcrel_lo_reloc
*lo_relocs
;
1523 } riscv_pcrel_relocs
;
1526 riscv_pcrel_reloc_hash (const void *entry
)
1528 const riscv_pcrel_hi_reloc
*e
= entry
;
1529 return (hashval_t
)(e
->address
>> 2);
1533 riscv_pcrel_reloc_eq (const void *entry1
, const void *entry2
)
1535 const riscv_pcrel_hi_reloc
*e1
= entry1
, *e2
= entry2
;
1536 return e1
->address
== e2
->address
;
1540 riscv_init_pcrel_relocs (riscv_pcrel_relocs
*p
)
1543 p
->lo_relocs
= NULL
;
1544 p
->hi_relocs
= htab_create (1024, riscv_pcrel_reloc_hash
,
1545 riscv_pcrel_reloc_eq
, free
);
1546 return p
->hi_relocs
!= NULL
;
1550 riscv_free_pcrel_relocs (riscv_pcrel_relocs
*p
)
1552 riscv_pcrel_lo_reloc
*cur
= p
->lo_relocs
;
1556 riscv_pcrel_lo_reloc
*next
= cur
->next
;
1561 htab_delete (p
->hi_relocs
);
1565 riscv_zero_pcrel_hi_reloc (Elf_Internal_Rela
*rel
,
1566 struct bfd_link_info
*info
,
1570 const reloc_howto_type
*howto
,
1573 /* We may need to reference low addreses in PC-relative modes even when the
1574 * PC is far away from these addresses. For example, undefweak references
1575 * need to produce the address 0 when linked. As 0 is far from the arbitrary
1576 * addresses that we can link PC-relative programs at, the linker can't
1577 * actually relocate references to those symbols. In order to allow these
1578 * programs to work we simply convert the PC-relative auipc sequences to
1579 * 0-relative lui sequences. */
1580 if (bfd_link_pic (info
))
1583 /* If it's possible to reference the symbol using auipc we do so, as that's
1584 * more in the spirit of the PC-relative relocations we're processing. */
1585 bfd_vma offset
= addr
- pc
;
1586 if (ARCH_SIZE
== 32 || VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (offset
)))
1589 /* If it's impossible to reference this with a LUI-based offset then don't
1590 * bother to convert it at all so users still see the PC-relative relocation
1591 * in the truncation message. */
1592 if (ARCH_SIZE
> 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (addr
)))
1595 rel
->r_info
= ELFNN_R_INFO(addr
, R_RISCV_HI20
);
1597 bfd_vma insn
= bfd_get(howto
->bitsize
, input_bfd
, contents
+ rel
->r_offset
);
1598 insn
= (insn
& ~MASK_AUIPC
) | MATCH_LUI
;
1599 bfd_put(howto
->bitsize
, input_bfd
, insn
, contents
+ rel
->r_offset
);
1604 riscv_record_pcrel_hi_reloc (riscv_pcrel_relocs
*p
, bfd_vma addr
,
1605 bfd_vma value
, bfd_boolean absolute
)
1607 bfd_vma offset
= absolute
? value
: value
- addr
;
1608 riscv_pcrel_hi_reloc entry
= {addr
, offset
};
1609 riscv_pcrel_hi_reloc
**slot
=
1610 (riscv_pcrel_hi_reloc
**) htab_find_slot (p
->hi_relocs
, &entry
, INSERT
);
1612 BFD_ASSERT (*slot
== NULL
);
1613 *slot
= (riscv_pcrel_hi_reloc
*) bfd_malloc (sizeof (riscv_pcrel_hi_reloc
));
1621 riscv_record_pcrel_lo_reloc (riscv_pcrel_relocs
*p
,
1622 asection
*input_section
,
1623 struct bfd_link_info
*info
,
1624 reloc_howto_type
*howto
,
1625 const Elf_Internal_Rela
*reloc
,
1630 riscv_pcrel_lo_reloc
*entry
;
1631 entry
= (riscv_pcrel_lo_reloc
*) bfd_malloc (sizeof (riscv_pcrel_lo_reloc
));
1634 *entry
= (riscv_pcrel_lo_reloc
) {input_section
, info
, howto
, reloc
, addr
,
1635 name
, contents
, p
->lo_relocs
};
1636 p
->lo_relocs
= entry
;
1641 riscv_resolve_pcrel_lo_relocs (riscv_pcrel_relocs
*p
)
1643 riscv_pcrel_lo_reloc
*r
;
1645 for (r
= p
->lo_relocs
; r
!= NULL
; r
= r
->next
)
1647 bfd
*input_bfd
= r
->input_section
->owner
;
1649 riscv_pcrel_hi_reloc search
= {r
->addr
, 0};
1650 riscv_pcrel_hi_reloc
*entry
= htab_find (p
->hi_relocs
, &search
);
1653 ((*r
->info
->callbacks
->reloc_overflow
)
1654 (r
->info
, NULL
, r
->name
, r
->howto
->name
, (bfd_vma
) 0,
1655 input_bfd
, r
->input_section
, r
->reloc
->r_offset
));
1659 perform_relocation (r
->howto
, r
->reloc
, entry
->value
, r
->input_section
,
1660 input_bfd
, r
->contents
);
1666 /* Relocate a RISC-V ELF section.
1668 The RELOCATE_SECTION function is called by the new ELF backend linker
1669 to handle the relocations for a section.
1671 The relocs are always passed as Rela structures.
1673 This function is responsible for adjusting the section contents as
1674 necessary, and (if generating a relocatable output file) adjusting
1675 the reloc addend as necessary.
1677 This function does not have to worry about setting the reloc
1678 address or the reloc symbol index.
1680 LOCAL_SYMS is a pointer to the swapped in local symbols.
1682 LOCAL_SECTIONS is an array giving the section in the input file
1683 corresponding to the st_shndx field of each local symbol.
1685 The global hash table entry for the global symbols can be found
1686 via elf_sym_hashes (input_bfd).
1688 When generating relocatable output, this function must handle
1689 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
1690 going to be the section symbol corresponding to the output
1691 section, which means that the addend must be adjusted
1695 riscv_elf_relocate_section (bfd
*output_bfd
,
1696 struct bfd_link_info
*info
,
1698 asection
*input_section
,
1700 Elf_Internal_Rela
*relocs
,
1701 Elf_Internal_Sym
*local_syms
,
1702 asection
**local_sections
)
1704 Elf_Internal_Rela
*rel
;
1705 Elf_Internal_Rela
*relend
;
1706 riscv_pcrel_relocs pcrel_relocs
;
1707 bfd_boolean ret
= FALSE
;
1708 asection
*sreloc
= elf_section_data (input_section
)->sreloc
;
1709 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
1710 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (input_bfd
);
1711 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (input_bfd
);
1712 bfd_vma
*local_got_offsets
= elf_local_got_offsets (input_bfd
);
1713 bfd_boolean absolute
;
1715 if (!riscv_init_pcrel_relocs (&pcrel_relocs
))
1718 relend
= relocs
+ input_section
->reloc_count
;
1719 for (rel
= relocs
; rel
< relend
; rel
++)
1721 unsigned long r_symndx
;
1722 struct elf_link_hash_entry
*h
;
1723 Elf_Internal_Sym
*sym
;
1726 bfd_reloc_status_type r
= bfd_reloc_ok
;
1728 bfd_vma off
, ie_off
;
1729 bfd_boolean unresolved_reloc
, is_ie
= FALSE
;
1730 bfd_vma pc
= sec_addr (input_section
) + rel
->r_offset
;
1731 int r_type
= ELFNN_R_TYPE (rel
->r_info
), tls_type
;
1732 reloc_howto_type
*howto
= riscv_elf_rtype_to_howto (input_bfd
, r_type
);
1733 const char *msg
= NULL
;
1736 || r_type
== R_RISCV_GNU_VTINHERIT
|| r_type
== R_RISCV_GNU_VTENTRY
)
1739 /* This is a final link. */
1740 r_symndx
= ELFNN_R_SYM (rel
->r_info
);
1744 unresolved_reloc
= FALSE
;
1745 if (r_symndx
< symtab_hdr
->sh_info
)
1747 sym
= local_syms
+ r_symndx
;
1748 sec
= local_sections
[r_symndx
];
1749 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
1753 bfd_boolean warned
, ignored
;
1755 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
1756 r_symndx
, symtab_hdr
, sym_hashes
,
1758 unresolved_reloc
, warned
, ignored
);
1761 /* To avoid generating warning messages about truncated
1762 relocations, set the relocation's address to be the same as
1763 the start of this section. */
1764 if (input_section
->output_section
!= NULL
)
1765 relocation
= input_section
->output_section
->vma
;
1771 if (sec
!= NULL
&& discarded_section (sec
))
1772 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
1773 rel
, 1, relend
, howto
, 0, contents
);
1775 if (bfd_link_relocatable (info
))
1779 name
= h
->root
.root
.string
;
1782 name
= (bfd_elf_string_from_elf_section
1783 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
1784 if (name
== NULL
|| *name
== '\0')
1785 name
= bfd_section_name (input_bfd
, sec
);
1792 case R_RISCV_TPREL_ADD
:
1794 case R_RISCV_JUMP_SLOT
:
1795 case R_RISCV_RELATIVE
:
1796 /* These require nothing of us at all. */
1800 case R_RISCV_BRANCH
:
1801 case R_RISCV_RVC_BRANCH
:
1802 case R_RISCV_RVC_LUI
:
1803 case R_RISCV_LO12_I
:
1804 case R_RISCV_LO12_S
:
1809 case R_RISCV_32_PCREL
:
1810 case R_RISCV_DELETE
:
1811 /* These require no special handling beyond perform_relocation. */
1814 case R_RISCV_GOT_HI20
:
1817 bfd_boolean dyn
, pic
;
1819 off
= h
->got
.offset
;
1820 BFD_ASSERT (off
!= (bfd_vma
) -1);
1821 dyn
= elf_hash_table (info
)->dynamic_sections_created
;
1822 pic
= bfd_link_pic (info
);
1824 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, pic
, h
)
1825 || (pic
&& SYMBOL_REFERENCES_LOCAL (info
, h
)))
1827 /* This is actually a static link, or it is a
1828 -Bsymbolic link and the symbol is defined
1829 locally, or the symbol was forced to be local
1830 because of a version file. We must initialize
1831 this entry in the global offset table. Since the
1832 offset must always be a multiple of the word size,
1833 we use the least significant bit to record whether
1834 we have initialized it already.
1836 When doing a dynamic link, we create a .rela.got
1837 relocation entry to initialize the value. This
1838 is done in the finish_dynamic_symbol routine. */
1843 bfd_put_NN (output_bfd
, relocation
,
1844 htab
->elf
.sgot
->contents
+ off
);
1849 unresolved_reloc
= FALSE
;
1853 BFD_ASSERT (local_got_offsets
!= NULL
1854 && local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
1856 off
= local_got_offsets
[r_symndx
];
1858 /* The offset must always be a multiple of the word size.
1859 So, we can use the least significant bit to record
1860 whether we have already processed this entry. */
1865 if (bfd_link_pic (info
))
1868 Elf_Internal_Rela outrel
;
1870 /* We need to generate a R_RISCV_RELATIVE reloc
1871 for the dynamic linker. */
1872 s
= htab
->elf
.srelgot
;
1873 BFD_ASSERT (s
!= NULL
);
1875 outrel
.r_offset
= sec_addr (htab
->elf
.sgot
) + off
;
1877 ELFNN_R_INFO (0, R_RISCV_RELATIVE
);
1878 outrel
.r_addend
= relocation
;
1880 riscv_elf_append_rela (output_bfd
, s
, &outrel
);
1883 bfd_put_NN (output_bfd
, relocation
,
1884 htab
->elf
.sgot
->contents
+ off
);
1885 local_got_offsets
[r_symndx
] |= 1;
1888 relocation
= sec_addr (htab
->elf
.sgot
) + off
;
1889 absolute
= riscv_zero_pcrel_hi_reloc (rel
,
1896 r_type
= ELFNN_R_TYPE (rel
->r_info
);
1897 howto
= riscv_elf_rtype_to_howto (input_bfd
, r_type
);
1899 r
= bfd_reloc_notsupported
;
1900 else if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs
, pc
,
1901 relocation
, absolute
))
1902 r
= bfd_reloc_overflow
;
1910 bfd_vma old_value
= bfd_get (howto
->bitsize
, input_bfd
,
1911 contents
+ rel
->r_offset
);
1912 relocation
= old_value
+ relocation
;
1922 bfd_vma old_value
= bfd_get (howto
->bitsize
, input_bfd
,
1923 contents
+ rel
->r_offset
);
1924 relocation
= old_value
- relocation
;
1928 case R_RISCV_CALL_PLT
:
1931 case R_RISCV_RVC_JUMP
:
1932 if (bfd_link_pic (info
) && h
!= NULL
&& h
->plt
.offset
!= MINUS_ONE
)
1934 /* Refer to the PLT entry. */
1935 relocation
= sec_addr (htab
->elf
.splt
) + h
->plt
.offset
;
1936 unresolved_reloc
= FALSE
;
1940 case R_RISCV_TPREL_HI20
:
1941 relocation
= tpoff (info
, relocation
);
1944 case R_RISCV_TPREL_LO12_I
:
1945 case R_RISCV_TPREL_LO12_S
:
1946 relocation
= tpoff (info
, relocation
);
1949 case R_RISCV_TPREL_I
:
1950 case R_RISCV_TPREL_S
:
1951 relocation
= tpoff (info
, relocation
);
1952 if (VALID_ITYPE_IMM (relocation
+ rel
->r_addend
))
1954 /* We can use tp as the base register. */
1955 bfd_vma insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
1956 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
1957 insn
|= X_TP
<< OP_SH_RS1
;
1958 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
1961 r
= bfd_reloc_overflow
;
1964 case R_RISCV_GPREL_I
:
1965 case R_RISCV_GPREL_S
:
1967 bfd_vma gp
= riscv_global_pointer_value (info
);
1968 bfd_boolean x0_base
= VALID_ITYPE_IMM (relocation
+ rel
->r_addend
);
1969 if (x0_base
|| VALID_ITYPE_IMM (relocation
+ rel
->r_addend
- gp
))
1971 /* We can use x0 or gp as the base register. */
1972 bfd_vma insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
1973 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
1976 rel
->r_addend
-= gp
;
1977 insn
|= X_GP
<< OP_SH_RS1
;
1979 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
1982 r
= bfd_reloc_overflow
;
1986 case R_RISCV_PCREL_HI20
:
1987 absolute
= riscv_zero_pcrel_hi_reloc (rel
,
1994 r_type
= ELFNN_R_TYPE (rel
->r_info
);
1995 howto
= riscv_elf_rtype_to_howto (input_bfd
, r_type
);
1997 r
= bfd_reloc_notsupported
;
1998 else if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs
, pc
,
1999 relocation
+ rel
->r_addend
,
2001 r
= bfd_reloc_overflow
;
2004 case R_RISCV_PCREL_LO12_I
:
2005 case R_RISCV_PCREL_LO12_S
:
2006 /* Addends are not allowed, because then riscv_relax_delete_bytes
2007 would have to search through all relocs to update the addends.
2008 Also, riscv_resolve_pcrel_lo_relocs does not support addends
2009 when searching for a matching hi reloc. */
2012 r
= bfd_reloc_dangerous
;
2016 if (riscv_record_pcrel_lo_reloc (&pcrel_relocs
, input_section
, info
,
2017 howto
, rel
, relocation
, name
,
2020 r
= bfd_reloc_overflow
;
2023 case R_RISCV_TLS_DTPREL32
:
2024 case R_RISCV_TLS_DTPREL64
:
2025 relocation
= dtpoff (info
, relocation
);
2030 if ((input_section
->flags
& SEC_ALLOC
) == 0)
2033 if ((bfd_link_pic (info
)
2035 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2036 || h
->root
.type
!= bfd_link_hash_undefweak
)
2037 && (! howto
->pc_relative
2038 || !SYMBOL_CALLS_LOCAL (info
, h
)))
2039 || (!bfd_link_pic (info
)
2045 || h
->root
.type
== bfd_link_hash_undefweak
2046 || h
->root
.type
== bfd_link_hash_undefined
)))
2048 Elf_Internal_Rela outrel
;
2049 bfd_boolean skip_static_relocation
, skip_dynamic_relocation
;
2051 /* When generating a shared object, these relocations
2052 are copied into the output file to be resolved at run
2056 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
2058 skip_static_relocation
= outrel
.r_offset
!= (bfd_vma
) -2;
2059 skip_dynamic_relocation
= outrel
.r_offset
>= (bfd_vma
) -2;
2060 outrel
.r_offset
+= sec_addr (input_section
);
2062 if (skip_dynamic_relocation
)
2063 memset (&outrel
, 0, sizeof outrel
);
2064 else if (h
!= NULL
&& h
->dynindx
!= -1
2065 && !(bfd_link_pic (info
)
2066 && SYMBOLIC_BIND (info
, h
)
2069 outrel
.r_info
= ELFNN_R_INFO (h
->dynindx
, r_type
);
2070 outrel
.r_addend
= rel
->r_addend
;
2074 outrel
.r_info
= ELFNN_R_INFO (0, R_RISCV_RELATIVE
);
2075 outrel
.r_addend
= relocation
+ rel
->r_addend
;
2078 riscv_elf_append_rela (output_bfd
, sreloc
, &outrel
);
2079 if (skip_static_relocation
)
2084 case R_RISCV_TLS_GOT_HI20
:
2088 case R_RISCV_TLS_GD_HI20
:
2091 off
= h
->got
.offset
;
2096 off
= local_got_offsets
[r_symndx
];
2097 local_got_offsets
[r_symndx
] |= 1;
2100 tls_type
= _bfd_riscv_elf_tls_type (input_bfd
, h
, r_symndx
);
2101 BFD_ASSERT (tls_type
& (GOT_TLS_IE
| GOT_TLS_GD
));
2102 /* If this symbol is referenced by both GD and IE TLS, the IE
2103 reference's GOT slot follows the GD reference's slots. */
2105 if ((tls_type
& GOT_TLS_GD
) && (tls_type
& GOT_TLS_IE
))
2106 ie_off
= 2 * GOT_ENTRY_SIZE
;
2112 Elf_Internal_Rela outrel
;
2114 bfd_boolean need_relocs
= FALSE
;
2116 if (htab
->elf
.srelgot
== NULL
)
2121 bfd_boolean dyn
, pic
;
2122 dyn
= htab
->elf
.dynamic_sections_created
;
2123 pic
= bfd_link_pic (info
);
2125 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, pic
, h
)
2126 && (!pic
|| !SYMBOL_REFERENCES_LOCAL (info
, h
)))
2130 /* The GOT entries have not been initialized yet. Do it
2131 now, and emit any relocations. */
2132 if ((bfd_link_pic (info
) || indx
!= 0)
2134 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2135 || h
->root
.type
!= bfd_link_hash_undefweak
))
2138 if (tls_type
& GOT_TLS_GD
)
2142 outrel
.r_offset
= sec_addr (htab
->elf
.sgot
) + off
;
2143 outrel
.r_addend
= 0;
2144 outrel
.r_info
= ELFNN_R_INFO (indx
, R_RISCV_TLS_DTPMODNN
);
2145 bfd_put_NN (output_bfd
, 0,
2146 htab
->elf
.sgot
->contents
+ off
);
2147 riscv_elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &outrel
);
2150 BFD_ASSERT (! unresolved_reloc
);
2151 bfd_put_NN (output_bfd
,
2152 dtpoff (info
, relocation
),
2153 (htab
->elf
.sgot
->contents
+ off
+
2154 RISCV_ELF_WORD_BYTES
));
2158 bfd_put_NN (output_bfd
, 0,
2159 (htab
->elf
.sgot
->contents
+ off
+
2160 RISCV_ELF_WORD_BYTES
));
2161 outrel
.r_info
= ELFNN_R_INFO (indx
, R_RISCV_TLS_DTPRELNN
);
2162 outrel
.r_offset
+= RISCV_ELF_WORD_BYTES
;
2163 riscv_elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &outrel
);
2168 /* If we are not emitting relocations for a
2169 general dynamic reference, then we must be in a
2170 static link or an executable link with the
2171 symbol binding locally. Mark it as belonging
2172 to module 1, the executable. */
2173 bfd_put_NN (output_bfd
, 1,
2174 htab
->elf
.sgot
->contents
+ off
);
2175 bfd_put_NN (output_bfd
,
2176 dtpoff (info
, relocation
),
2177 (htab
->elf
.sgot
->contents
+ off
+
2178 RISCV_ELF_WORD_BYTES
));
2182 if (tls_type
& GOT_TLS_IE
)
2186 bfd_put_NN (output_bfd
, 0,
2187 htab
->elf
.sgot
->contents
+ off
+ ie_off
);
2188 outrel
.r_offset
= sec_addr (htab
->elf
.sgot
)
2190 outrel
.r_addend
= 0;
2192 outrel
.r_addend
= tpoff (info
, relocation
);
2193 outrel
.r_info
= ELFNN_R_INFO (indx
, R_RISCV_TLS_TPRELNN
);
2194 riscv_elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &outrel
);
2198 bfd_put_NN (output_bfd
, tpoff (info
, relocation
),
2199 htab
->elf
.sgot
->contents
+ off
+ ie_off
);
2204 BFD_ASSERT (off
< (bfd_vma
) -2);
2205 relocation
= sec_addr (htab
->elf
.sgot
) + off
+ (is_ie
? ie_off
: 0);
2206 if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs
, pc
,
2208 r
= bfd_reloc_overflow
;
2209 unresolved_reloc
= FALSE
;
2213 r
= bfd_reloc_notsupported
;
2216 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2217 because such sections are not SEC_ALLOC and thus ld.so will
2218 not process them. */
2219 if (unresolved_reloc
2220 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
2222 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
2223 rel
->r_offset
) != (bfd_vma
) -1)
2225 (*_bfd_error_handler
)
2226 (_("%pB(%pA+%#" PRIx64
"): "
2227 "unresolvable %s relocation against symbol `%s'"),
2230 (uint64_t) rel
->r_offset
,
2232 h
->root
.root
.string
);
2236 if (r
== bfd_reloc_ok
)
2237 r
= perform_relocation (howto
, rel
, relocation
, input_section
,
2238 input_bfd
, contents
);
2245 case bfd_reloc_overflow
:
2246 info
->callbacks
->reloc_overflow
2247 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
2248 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
2251 case bfd_reloc_undefined
:
2252 info
->callbacks
->undefined_symbol
2253 (info
, name
, input_bfd
, input_section
, rel
->r_offset
,
2257 case bfd_reloc_outofrange
:
2258 msg
= _("%X%P: internal error: out of range error\n");
2261 case bfd_reloc_notsupported
:
2262 msg
= _("%X%P: internal error: unsupported relocation error\n");
2265 case bfd_reloc_dangerous
:
2266 info
->callbacks
->reloc_dangerous
2267 (info
, "%pcrel_lo with addend", input_bfd
, input_section
,
2272 msg
= _("%X%P: internal error: unknown error\n");
2277 info
->callbacks
->einfo (msg
);
2279 /* We already reported the error via a callback, so don't try to report
2280 it again by returning false. That leads to spurious errors. */
2285 ret
= riscv_resolve_pcrel_lo_relocs (&pcrel_relocs
);
2287 riscv_free_pcrel_relocs (&pcrel_relocs
);
2291 /* Finish up dynamic symbol handling. We set the contents of various
2292 dynamic sections here. */
2295 riscv_elf_finish_dynamic_symbol (bfd
*output_bfd
,
2296 struct bfd_link_info
*info
,
2297 struct elf_link_hash_entry
*h
,
2298 Elf_Internal_Sym
*sym
)
2300 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
2301 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
2303 if (h
->plt
.offset
!= (bfd_vma
) -1)
2305 /* We've decided to create a PLT entry for this symbol. */
2307 bfd_vma i
, header_address
, plt_idx
, got_address
;
2308 uint32_t plt_entry
[PLT_ENTRY_INSNS
];
2309 Elf_Internal_Rela rela
;
2311 BFD_ASSERT (h
->dynindx
!= -1);
2313 /* Calculate the address of the PLT header. */
2314 header_address
= sec_addr (htab
->elf
.splt
);
2316 /* Calculate the index of the entry. */
2317 plt_idx
= (h
->plt
.offset
- PLT_HEADER_SIZE
) / PLT_ENTRY_SIZE
;
2319 /* Calculate the address of the .got.plt entry. */
2320 got_address
= riscv_elf_got_plt_val (plt_idx
, info
);
2322 /* Find out where the .plt entry should go. */
2323 loc
= htab
->elf
.splt
->contents
+ h
->plt
.offset
;
2325 /* Fill in the PLT entry itself. */
2326 riscv_make_plt_entry (got_address
, header_address
+ h
->plt
.offset
,
2328 for (i
= 0; i
< PLT_ENTRY_INSNS
; i
++)
2329 bfd_put_32 (output_bfd
, plt_entry
[i
], loc
+ 4*i
);
2331 /* Fill in the initial value of the .got.plt entry. */
2332 loc
= htab
->elf
.sgotplt
->contents
2333 + (got_address
- sec_addr (htab
->elf
.sgotplt
));
2334 bfd_put_NN (output_bfd
, sec_addr (htab
->elf
.splt
), loc
);
2336 /* Fill in the entry in the .rela.plt section. */
2337 rela
.r_offset
= got_address
;
2339 rela
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_RISCV_JUMP_SLOT
);
2341 loc
= htab
->elf
.srelplt
->contents
+ plt_idx
* sizeof (ElfNN_External_Rela
);
2342 bed
->s
->swap_reloca_out (output_bfd
, &rela
, loc
);
2344 if (!h
->def_regular
)
2346 /* Mark the symbol as undefined, rather than as defined in
2347 the .plt section. Leave the value alone. */
2348 sym
->st_shndx
= SHN_UNDEF
;
2349 /* If the symbol is weak, we do need to clear the value.
2350 Otherwise, the PLT entry would provide a definition for
2351 the symbol even if the symbol wasn't defined anywhere,
2352 and so the symbol would never be NULL. */
2353 if (!h
->ref_regular_nonweak
)
2358 if (h
->got
.offset
!= (bfd_vma
) -1
2359 && !(riscv_elf_hash_entry (h
)->tls_type
& (GOT_TLS_GD
| GOT_TLS_IE
)))
2363 Elf_Internal_Rela rela
;
2365 /* This symbol has an entry in the GOT. Set it up. */
2367 sgot
= htab
->elf
.sgot
;
2368 srela
= htab
->elf
.srelgot
;
2369 BFD_ASSERT (sgot
!= NULL
&& srela
!= NULL
);
2371 rela
.r_offset
= sec_addr (sgot
) + (h
->got
.offset
&~ (bfd_vma
) 1);
2373 /* If this is a -Bsymbolic link, and the symbol is defined
2374 locally, we just want to emit a RELATIVE reloc. Likewise if
2375 the symbol was forced to be local because of a version file.
2376 The entry in the global offset table will already have been
2377 initialized in the relocate_section function. */
2378 if (bfd_link_pic (info
)
2379 && (info
->symbolic
|| h
->dynindx
== -1)
2382 asection
*sec
= h
->root
.u
.def
.section
;
2383 rela
.r_info
= ELFNN_R_INFO (0, R_RISCV_RELATIVE
);
2384 rela
.r_addend
= (h
->root
.u
.def
.value
2385 + sec
->output_section
->vma
2386 + sec
->output_offset
);
2390 BFD_ASSERT (h
->dynindx
!= -1);
2391 rela
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_RISCV_NN
);
2395 bfd_put_NN (output_bfd
, 0,
2396 sgot
->contents
+ (h
->got
.offset
& ~(bfd_vma
) 1));
2397 riscv_elf_append_rela (output_bfd
, srela
, &rela
);
2402 Elf_Internal_Rela rela
;
2405 /* This symbols needs a copy reloc. Set it up. */
2406 BFD_ASSERT (h
->dynindx
!= -1);
2408 rela
.r_offset
= sec_addr (h
->root
.u
.def
.section
) + h
->root
.u
.def
.value
;
2409 rela
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_RISCV_COPY
);
2411 if (h
->root
.u
.def
.section
== htab
->elf
.sdynrelro
)
2412 s
= htab
->elf
.sreldynrelro
;
2414 s
= htab
->elf
.srelbss
;
2415 riscv_elf_append_rela (output_bfd
, s
, &rela
);
2418 /* Mark some specially defined symbols as absolute. */
2419 if (h
== htab
->elf
.hdynamic
2420 || (h
== htab
->elf
.hgot
|| h
== htab
->elf
.hplt
))
2421 sym
->st_shndx
= SHN_ABS
;
2426 /* Finish up the dynamic sections. */
2429 riscv_finish_dyn (bfd
*output_bfd
, struct bfd_link_info
*info
,
2430 bfd
*dynobj
, asection
*sdyn
)
2432 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
2433 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
2434 size_t dynsize
= bed
->s
->sizeof_dyn
;
2435 bfd_byte
*dyncon
, *dynconend
;
2437 dynconend
= sdyn
->contents
+ sdyn
->size
;
2438 for (dyncon
= sdyn
->contents
; dyncon
< dynconend
; dyncon
+= dynsize
)
2440 Elf_Internal_Dyn dyn
;
2443 bed
->s
->swap_dyn_in (dynobj
, dyncon
, &dyn
);
2448 s
= htab
->elf
.sgotplt
;
2449 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
2452 s
= htab
->elf
.srelplt
;
2453 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
2456 s
= htab
->elf
.srelplt
;
2457 dyn
.d_un
.d_val
= s
->size
;
2463 bed
->s
->swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2469 riscv_elf_finish_dynamic_sections (bfd
*output_bfd
,
2470 struct bfd_link_info
*info
)
2474 struct riscv_elf_link_hash_table
*htab
;
2476 htab
= riscv_elf_hash_table (info
);
2477 BFD_ASSERT (htab
!= NULL
);
2478 dynobj
= htab
->elf
.dynobj
;
2480 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
2482 if (elf_hash_table (info
)->dynamic_sections_created
)
2487 splt
= htab
->elf
.splt
;
2488 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
2490 ret
= riscv_finish_dyn (output_bfd
, info
, dynobj
, sdyn
);
2495 /* Fill in the head and tail entries in the procedure linkage table. */
2499 uint32_t plt_header
[PLT_HEADER_INSNS
];
2500 riscv_make_plt_header (sec_addr (htab
->elf
.sgotplt
),
2501 sec_addr (splt
), plt_header
);
2503 for (i
= 0; i
< PLT_HEADER_INSNS
; i
++)
2504 bfd_put_32 (output_bfd
, plt_header
[i
], splt
->contents
+ 4*i
);
2506 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
2511 if (htab
->elf
.sgotplt
)
2513 asection
*output_section
= htab
->elf
.sgotplt
->output_section
;
2515 if (bfd_is_abs_section (output_section
))
2517 (*_bfd_error_handler
)
2518 (_("discarded output section: `%pA'"), htab
->elf
.sgotplt
);
2522 if (htab
->elf
.sgotplt
->size
> 0)
2524 /* Write the first two entries in .got.plt, needed for the dynamic
2526 bfd_put_NN (output_bfd
, (bfd_vma
) -1, htab
->elf
.sgotplt
->contents
);
2527 bfd_put_NN (output_bfd
, (bfd_vma
) 0,
2528 htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
);
2531 elf_section_data (output_section
)->this_hdr
.sh_entsize
= GOT_ENTRY_SIZE
;
2536 asection
*output_section
= htab
->elf
.sgot
->output_section
;
2538 if (htab
->elf
.sgot
->size
> 0)
2540 /* Set the first entry in the global offset table to the address of
2541 the dynamic section. */
2542 bfd_vma val
= sdyn
? sec_addr (sdyn
) : 0;
2543 bfd_put_NN (output_bfd
, val
, htab
->elf
.sgot
->contents
);
2546 elf_section_data (output_section
)->this_hdr
.sh_entsize
= GOT_ENTRY_SIZE
;
2552 /* Return address for Ith PLT stub in section PLT, for relocation REL
2553 or (bfd_vma) -1 if it should not be included. */
2556 riscv_elf_plt_sym_val (bfd_vma i
, const asection
*plt
,
2557 const arelent
*rel ATTRIBUTE_UNUSED
)
2559 return plt
->vma
+ PLT_HEADER_SIZE
+ i
* PLT_ENTRY_SIZE
;
2562 static enum elf_reloc_type_class
2563 riscv_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2564 const asection
*rel_sec ATTRIBUTE_UNUSED
,
2565 const Elf_Internal_Rela
*rela
)
2567 switch (ELFNN_R_TYPE (rela
->r_info
))
2569 case R_RISCV_RELATIVE
:
2570 return reloc_class_relative
;
2571 case R_RISCV_JUMP_SLOT
:
2572 return reloc_class_plt
;
2574 return reloc_class_copy
;
2576 return reloc_class_normal
;
2580 /* Merge backend specific data from an object file to the output
2581 object file when linking. */
2584 _bfd_riscv_elf_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
2586 bfd
*obfd
= info
->output_bfd
;
2587 flagword new_flags
= elf_elfheader (ibfd
)->e_flags
;
2588 flagword old_flags
= elf_elfheader (obfd
)->e_flags
;
2590 if (!is_riscv_elf (ibfd
) || !is_riscv_elf (obfd
))
2593 if (strcmp (bfd_get_target (ibfd
), bfd_get_target (obfd
)) != 0)
2595 (*_bfd_error_handler
)
2596 (_("%pB: ABI is incompatible with that of the selected emulation:\n"
2597 " target emulation `%s' does not match `%s'"),
2598 ibfd
, bfd_get_target (ibfd
), bfd_get_target (obfd
));
2602 if (!_bfd_elf_merge_object_attributes (ibfd
, info
))
2605 if (! elf_flags_init (obfd
))
2607 elf_flags_init (obfd
) = TRUE
;
2608 elf_elfheader (obfd
)->e_flags
= new_flags
;
2612 /* Disallow linking different float ABIs. */
2613 if ((old_flags
^ new_flags
) & EF_RISCV_FLOAT_ABI
)
2615 (*_bfd_error_handler
)
2616 (_("%pB: can't link hard-float modules with soft-float modules"), ibfd
);
2620 /* Allow linking RVC and non-RVC, and keep the RVC flag. */
2621 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_RISCV_RVC
;
2626 bfd_set_error (bfd_error_bad_value
);
2630 /* Delete some bytes from a section while relaxing. */
2633 riscv_relax_delete_bytes (bfd
*abfd
, asection
*sec
, bfd_vma addr
, size_t count
,
2634 struct bfd_link_info
*link_info
)
2636 unsigned int i
, symcount
;
2637 bfd_vma toaddr
= sec
->size
;
2638 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (abfd
);
2639 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2640 unsigned int sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
2641 struct bfd_elf_section_data
*data
= elf_section_data (sec
);
2642 bfd_byte
*contents
= data
->this_hdr
.contents
;
2644 /* Actually delete the bytes. */
2646 memmove (contents
+ addr
, contents
+ addr
+ count
, toaddr
- addr
- count
);
2648 /* Adjust the location of all of the relocs. Note that we need not
2649 adjust the addends, since all PC-relative references must be against
2650 symbols, which we will adjust below. */
2651 for (i
= 0; i
< sec
->reloc_count
; i
++)
2652 if (data
->relocs
[i
].r_offset
> addr
&& data
->relocs
[i
].r_offset
< toaddr
)
2653 data
->relocs
[i
].r_offset
-= count
;
2655 /* Adjust the local symbols defined in this section. */
2656 for (i
= 0; i
< symtab_hdr
->sh_info
; i
++)
2658 Elf_Internal_Sym
*sym
= (Elf_Internal_Sym
*) symtab_hdr
->contents
+ i
;
2659 if (sym
->st_shndx
== sec_shndx
)
2661 /* If the symbol is in the range of memory we just moved, we
2662 have to adjust its value. */
2663 if (sym
->st_value
> addr
&& sym
->st_value
<= toaddr
)
2664 sym
->st_value
-= count
;
2666 /* If the symbol *spans* the bytes we just deleted (i.e. its
2667 *end* is in the moved bytes but its *start* isn't), then we
2668 must adjust its size.
2670 This test needs to use the original value of st_value, otherwise
2671 we might accidentally decrease size when deleting bytes right
2672 before the symbol. But since deleted relocs can't span across
2673 symbols, we can't have both a st_value and a st_size decrease,
2674 so it is simpler to just use an else. */
2675 else if (sym
->st_value
<= addr
2676 && sym
->st_value
+ sym
->st_size
> addr
2677 && sym
->st_value
+ sym
->st_size
<= toaddr
)
2678 sym
->st_size
-= count
;
2682 /* Now adjust the global symbols defined in this section. */
2683 symcount
= ((symtab_hdr
->sh_size
/ sizeof (ElfNN_External_Sym
))
2684 - symtab_hdr
->sh_info
);
2686 for (i
= 0; i
< symcount
; i
++)
2688 struct elf_link_hash_entry
*sym_hash
= sym_hashes
[i
];
2690 /* The '--wrap SYMBOL' option is causing a pain when the object file,
2691 containing the definition of __wrap_SYMBOL, includes a direct
2692 call to SYMBOL as well. Since both __wrap_SYMBOL and SYMBOL reference
2693 the same symbol (which is __wrap_SYMBOL), but still exist as two
2694 different symbols in 'sym_hashes', we don't want to adjust
2695 the global symbol __wrap_SYMBOL twice.
2696 This check is only relevant when symbols are being wrapped. */
2697 if (link_info
->wrap_hash
!= NULL
)
2699 struct elf_link_hash_entry
**cur_sym_hashes
;
2701 /* Loop only over the symbols which have already been checked. */
2702 for (cur_sym_hashes
= sym_hashes
; cur_sym_hashes
< &sym_hashes
[i
];
2705 /* If the current symbol is identical to 'sym_hash', that means
2706 the symbol was already adjusted (or at least checked). */
2707 if (*cur_sym_hashes
== sym_hash
)
2710 /* Don't adjust the symbol again. */
2711 if (cur_sym_hashes
< &sym_hashes
[i
])
2715 if ((sym_hash
->root
.type
== bfd_link_hash_defined
2716 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
2717 && sym_hash
->root
.u
.def
.section
== sec
)
2719 /* As above, adjust the value if needed. */
2720 if (sym_hash
->root
.u
.def
.value
> addr
2721 && sym_hash
->root
.u
.def
.value
<= toaddr
)
2722 sym_hash
->root
.u
.def
.value
-= count
;
2724 /* As above, adjust the size if needed. */
2725 else if (sym_hash
->root
.u
.def
.value
<= addr
2726 && sym_hash
->root
.u
.def
.value
+ sym_hash
->size
> addr
2727 && sym_hash
->root
.u
.def
.value
+ sym_hash
->size
<= toaddr
)
2728 sym_hash
->size
-= count
;
2735 /* A second format for recording PC-relative hi relocations. This stores the
2736 information required to relax them to GP-relative addresses. */
2738 typedef struct riscv_pcgp_hi_reloc riscv_pcgp_hi_reloc
;
2739 struct riscv_pcgp_hi_reloc
2746 riscv_pcgp_hi_reloc
*next
;
2749 typedef struct riscv_pcgp_lo_reloc riscv_pcgp_lo_reloc
;
2750 struct riscv_pcgp_lo_reloc
2753 riscv_pcgp_lo_reloc
*next
;
2758 riscv_pcgp_hi_reloc
*hi
;
2759 riscv_pcgp_lo_reloc
*lo
;
2760 } riscv_pcgp_relocs
;
2763 riscv_init_pcgp_relocs (riscv_pcgp_relocs
*p
)
2771 riscv_free_pcgp_relocs (riscv_pcgp_relocs
*p
,
2772 bfd
*abfd ATTRIBUTE_UNUSED
,
2773 asection
*sec ATTRIBUTE_UNUSED
)
2775 riscv_pcgp_hi_reloc
*c
;
2776 riscv_pcgp_lo_reloc
*l
;
2778 for (c
= p
->hi
; c
!= NULL
;)
2780 riscv_pcgp_hi_reloc
*next
= c
->next
;
2785 for (l
= p
->lo
; l
!= NULL
;)
2787 riscv_pcgp_lo_reloc
*next
= l
->next
;
2794 riscv_record_pcgp_hi_reloc (riscv_pcgp_relocs
*p
, bfd_vma hi_sec_off
,
2795 bfd_vma hi_addend
, bfd_vma hi_addr
,
2796 unsigned hi_sym
, asection
*sym_sec
)
2798 riscv_pcgp_hi_reloc
*new = bfd_malloc (sizeof(*new));
2801 new->hi_sec_off
= hi_sec_off
;
2802 new->hi_addend
= hi_addend
;
2803 new->hi_addr
= hi_addr
;
2804 new->hi_sym
= hi_sym
;
2805 new->sym_sec
= sym_sec
;
2811 static riscv_pcgp_hi_reloc
*
2812 riscv_find_pcgp_hi_reloc(riscv_pcgp_relocs
*p
, bfd_vma hi_sec_off
)
2814 riscv_pcgp_hi_reloc
*c
;
2816 for (c
= p
->hi
; c
!= NULL
; c
= c
->next
)
2817 if (c
->hi_sec_off
== hi_sec_off
)
2823 riscv_delete_pcgp_hi_reloc(riscv_pcgp_relocs
*p
, bfd_vma hi_sec_off
)
2825 bfd_boolean out
= FALSE
;
2826 riscv_pcgp_hi_reloc
*c
;
2828 for (c
= p
->hi
; c
!= NULL
; c
= c
->next
)
2829 if (c
->hi_sec_off
== hi_sec_off
)
2836 riscv_use_pcgp_hi_reloc(riscv_pcgp_relocs
*p
, bfd_vma hi_sec_off
)
2838 bfd_boolean out
= FALSE
;
2839 riscv_pcgp_hi_reloc
*c
;
2841 for (c
= p
->hi
; c
!= NULL
; c
= c
->next
)
2842 if (c
->hi_sec_off
== hi_sec_off
)
2849 riscv_record_pcgp_lo_reloc (riscv_pcgp_relocs
*p
, bfd_vma hi_sec_off
)
2851 riscv_pcgp_lo_reloc
*new = bfd_malloc (sizeof(*new));
2854 new->hi_sec_off
= hi_sec_off
;
2861 riscv_find_pcgp_lo_reloc (riscv_pcgp_relocs
*p
, bfd_vma hi_sec_off
)
2863 riscv_pcgp_lo_reloc
*c
;
2865 for (c
= p
->lo
; c
!= NULL
; c
= c
->next
)
2866 if (c
->hi_sec_off
== hi_sec_off
)
2872 riscv_delete_pcgp_lo_reloc (riscv_pcgp_relocs
*p ATTRIBUTE_UNUSED
,
2873 bfd_vma lo_sec_off ATTRIBUTE_UNUSED
,
2874 size_t bytes ATTRIBUTE_UNUSED
)
2879 typedef bfd_boolean (*relax_func_t
) (bfd
*, asection
*, asection
*,
2880 struct bfd_link_info
*,
2881 Elf_Internal_Rela
*,
2882 bfd_vma
, bfd_vma
, bfd_vma
, bfd_boolean
*,
2883 riscv_pcgp_relocs
*);
2885 /* Relax AUIPC + JALR into JAL. */
2888 _bfd_riscv_relax_call (bfd
*abfd
, asection
*sec
, asection
*sym_sec
,
2889 struct bfd_link_info
*link_info
,
2890 Elf_Internal_Rela
*rel
,
2892 bfd_vma max_alignment
,
2893 bfd_vma reserve_size ATTRIBUTE_UNUSED
,
2895 riscv_pcgp_relocs
*pcgp_relocs ATTRIBUTE_UNUSED
)
2897 bfd_byte
*contents
= elf_section_data (sec
)->this_hdr
.contents
;
2898 bfd_signed_vma foff
= symval
- (sec_addr (sec
) + rel
->r_offset
);
2899 bfd_boolean near_zero
= (symval
+ RISCV_IMM_REACH
/2) < RISCV_IMM_REACH
;
2900 bfd_vma auipc
, jalr
;
2901 int rd
, r_type
, len
= 4, rvc
= elf_elfheader (abfd
)->e_flags
& EF_RISCV_RVC
;
2903 /* If the call crosses section boundaries, an alignment directive could
2904 cause the PC-relative offset to later increase. */
2905 if (VALID_UJTYPE_IMM (foff
) && sym_sec
->output_section
!= sec
->output_section
)
2906 foff
+= (foff
< 0 ? -max_alignment
: max_alignment
);
2908 /* See if this function call can be shortened. */
2909 if (!VALID_UJTYPE_IMM (foff
) && !(!bfd_link_pic (link_info
) && near_zero
))
2912 /* Shorten the function call. */
2913 BFD_ASSERT (rel
->r_offset
+ 8 <= sec
->size
);
2915 auipc
= bfd_get_32 (abfd
, contents
+ rel
->r_offset
);
2916 jalr
= bfd_get_32 (abfd
, contents
+ rel
->r_offset
+ 4);
2917 rd
= (jalr
>> OP_SH_RD
) & OP_MASK_RD
;
2918 rvc
= rvc
&& VALID_RVC_J_IMM (foff
) && ARCH_SIZE
== 32;
2920 if (rvc
&& (rd
== 0 || rd
== X_RA
))
2922 /* Relax to C.J[AL] rd, addr. */
2923 r_type
= R_RISCV_RVC_JUMP
;
2924 auipc
= rd
== 0 ? MATCH_C_J
: MATCH_C_JAL
;
2927 else if (VALID_UJTYPE_IMM (foff
))
2929 /* Relax to JAL rd, addr. */
2930 r_type
= R_RISCV_JAL
;
2931 auipc
= MATCH_JAL
| (rd
<< OP_SH_RD
);
2933 else /* near_zero */
2935 /* Relax to JALR rd, x0, addr. */
2936 r_type
= R_RISCV_LO12_I
;
2937 auipc
= MATCH_JALR
| (rd
<< OP_SH_RD
);
2940 /* Replace the R_RISCV_CALL reloc. */
2941 rel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (rel
->r_info
), r_type
);
2942 /* Replace the AUIPC. */
2943 bfd_put (8 * len
, abfd
, auipc
, contents
+ rel
->r_offset
);
2945 /* Delete unnecessary JALR. */
2947 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
+ len
, 8 - len
,
2951 /* Traverse all output sections and return the max alignment. */
2954 _bfd_riscv_get_max_alignment (asection
*sec
)
2956 unsigned int max_alignment_power
= 0;
2959 for (o
= sec
->output_section
->owner
->sections
; o
!= NULL
; o
= o
->next
)
2961 if (o
->alignment_power
> max_alignment_power
)
2962 max_alignment_power
= o
->alignment_power
;
2965 return (bfd_vma
) 1 << max_alignment_power
;
2968 /* Relax non-PIC global variable references. */
2971 _bfd_riscv_relax_lui (bfd
*abfd
,
2974 struct bfd_link_info
*link_info
,
2975 Elf_Internal_Rela
*rel
,
2977 bfd_vma max_alignment
,
2978 bfd_vma reserve_size
,
2980 riscv_pcgp_relocs
*pcgp_relocs ATTRIBUTE_UNUSED
)
2982 bfd_byte
*contents
= elf_section_data (sec
)->this_hdr
.contents
;
2983 bfd_vma gp
= riscv_global_pointer_value (link_info
);
2984 int use_rvc
= elf_elfheader (abfd
)->e_flags
& EF_RISCV_RVC
;
2986 /* Mergeable symbols and code might later move out of range. */
2987 if (sym_sec
->flags
& (SEC_MERGE
| SEC_CODE
))
2990 BFD_ASSERT (rel
->r_offset
+ 4 <= sec
->size
);
2994 /* If gp and the symbol are in the same output section, then
2995 consider only that section's alignment. */
2996 struct bfd_link_hash_entry
*h
=
2997 bfd_link_hash_lookup (link_info
->hash
, RISCV_GP_SYMBOL
, FALSE
, FALSE
,
2999 if (h
->u
.def
.section
->output_section
== sym_sec
->output_section
)
3000 max_alignment
= (bfd_vma
) 1 << sym_sec
->output_section
->alignment_power
;
3003 /* Is the reference in range of x0 or gp?
3004 Valid gp range conservatively because of alignment issue. */
3005 if (VALID_ITYPE_IMM (symval
)
3007 && VALID_ITYPE_IMM (symval
- gp
+ max_alignment
+ reserve_size
))
3009 && VALID_ITYPE_IMM (symval
- gp
- max_alignment
- reserve_size
)))
3011 unsigned sym
= ELFNN_R_SYM (rel
->r_info
);
3012 switch (ELFNN_R_TYPE (rel
->r_info
))
3014 case R_RISCV_LO12_I
:
3015 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_GPREL_I
);
3018 case R_RISCV_LO12_S
:
3019 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_GPREL_S
);
3023 /* We can delete the unnecessary LUI and reloc. */
3024 rel
->r_info
= ELFNN_R_INFO (0, R_RISCV_NONE
);
3026 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
, 4,
3034 /* Can we relax LUI to C.LUI? Alignment might move the section forward;
3035 account for this assuming page alignment at worst. */
3037 && ELFNN_R_TYPE (rel
->r_info
) == R_RISCV_HI20
3038 && VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (symval
))
3039 && VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (symval
+ ELF_MAXPAGESIZE
)))
3041 /* Replace LUI with C.LUI if legal (i.e., rd != x0 and rd != x2/sp). */
3042 bfd_vma lui
= bfd_get_32 (abfd
, contents
+ rel
->r_offset
);
3043 unsigned rd
= ((unsigned)lui
>> OP_SH_RD
) & OP_MASK_RD
;
3044 if (rd
== 0 || rd
== X_SP
)
3047 lui
= (lui
& (OP_MASK_RD
<< OP_SH_RD
)) | MATCH_C_LUI
;
3048 bfd_put_32 (abfd
, lui
, contents
+ rel
->r_offset
);
3050 /* Replace the R_RISCV_HI20 reloc. */
3051 rel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (rel
->r_info
), R_RISCV_RVC_LUI
);
3054 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
+ 2, 2,
3061 /* Relax non-PIC TLS references. */
3064 _bfd_riscv_relax_tls_le (bfd
*abfd
,
3066 asection
*sym_sec ATTRIBUTE_UNUSED
,
3067 struct bfd_link_info
*link_info
,
3068 Elf_Internal_Rela
*rel
,
3070 bfd_vma max_alignment ATTRIBUTE_UNUSED
,
3071 bfd_vma reserve_size ATTRIBUTE_UNUSED
,
3073 riscv_pcgp_relocs
*prcel_relocs ATTRIBUTE_UNUSED
)
3075 /* See if this symbol is in range of tp. */
3076 if (RISCV_CONST_HIGH_PART (tpoff (link_info
, symval
)) != 0)
3079 BFD_ASSERT (rel
->r_offset
+ 4 <= sec
->size
);
3080 switch (ELFNN_R_TYPE (rel
->r_info
))
3082 case R_RISCV_TPREL_LO12_I
:
3083 rel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (rel
->r_info
), R_RISCV_TPREL_I
);
3086 case R_RISCV_TPREL_LO12_S
:
3087 rel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (rel
->r_info
), R_RISCV_TPREL_S
);
3090 case R_RISCV_TPREL_HI20
:
3091 case R_RISCV_TPREL_ADD
:
3092 /* We can delete the unnecessary instruction and reloc. */
3093 rel
->r_info
= ELFNN_R_INFO (0, R_RISCV_NONE
);
3095 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
, 4, link_info
);
3102 /* Implement R_RISCV_ALIGN by deleting excess alignment NOPs. */
3105 _bfd_riscv_relax_align (bfd
*abfd
, asection
*sec
,
3107 struct bfd_link_info
*link_info
,
3108 Elf_Internal_Rela
*rel
,
3110 bfd_vma max_alignment ATTRIBUTE_UNUSED
,
3111 bfd_vma reserve_size ATTRIBUTE_UNUSED
,
3112 bfd_boolean
*again ATTRIBUTE_UNUSED
,
3113 riscv_pcgp_relocs
*pcrel_relocs ATTRIBUTE_UNUSED
)
3115 bfd_byte
*contents
= elf_section_data (sec
)->this_hdr
.contents
;
3116 bfd_vma alignment
= 1, pos
;
3117 while (alignment
<= rel
->r_addend
)
3120 symval
-= rel
->r_addend
;
3121 bfd_vma aligned_addr
= ((symval
- 1) & ~(alignment
- 1)) + alignment
;
3122 bfd_vma nop_bytes
= aligned_addr
- symval
;
3124 /* Once we've handled an R_RISCV_ALIGN, we can't relax anything else. */
3125 sec
->sec_flg0
= TRUE
;
3127 /* Make sure there are enough NOPs to actually achieve the alignment. */
3128 if (rel
->r_addend
< nop_bytes
)
3131 (_("%pB(%pA+%#" PRIx64
"): %" PRId64
" bytes required for alignment "
3132 "to %" PRId64
"-byte boundary, but only %" PRId64
" present"),
3133 abfd
, sym_sec
, (uint64_t) rel
->r_offset
,
3134 (int64_t) nop_bytes
, (int64_t) alignment
, (int64_t) rel
->r_addend
);
3135 bfd_set_error (bfd_error_bad_value
);
3139 /* Delete the reloc. */
3140 rel
->r_info
= ELFNN_R_INFO (0, R_RISCV_NONE
);
3142 /* If the number of NOPs is already correct, there's nothing to do. */
3143 if (nop_bytes
== rel
->r_addend
)
3146 /* Write as many RISC-V NOPs as we need. */
3147 for (pos
= 0; pos
< (nop_bytes
& -4); pos
+= 4)
3148 bfd_put_32 (abfd
, RISCV_NOP
, contents
+ rel
->r_offset
+ pos
);
3150 /* Write a final RVC NOP if need be. */
3151 if (nop_bytes
% 4 != 0)
3152 bfd_put_16 (abfd
, RVC_NOP
, contents
+ rel
->r_offset
+ pos
);
3154 /* Delete the excess bytes. */
3155 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
+ nop_bytes
,
3156 rel
->r_addend
- nop_bytes
, link_info
);
3159 /* Relax PC-relative references to GP-relative references. */
3162 _bfd_riscv_relax_pc (bfd
*abfd
,
3165 struct bfd_link_info
*link_info
,
3166 Elf_Internal_Rela
*rel
,
3168 bfd_vma max_alignment
,
3169 bfd_vma reserve_size
,
3170 bfd_boolean
*again ATTRIBUTE_UNUSED
,
3171 riscv_pcgp_relocs
*pcgp_relocs
)
3173 bfd_vma gp
= riscv_global_pointer_value (link_info
);
3175 BFD_ASSERT (rel
->r_offset
+ 4 <= sec
->size
);
3177 /* Chain the _LO relocs to their cooresponding _HI reloc to compute the
3178 * actual target address. */
3179 riscv_pcgp_hi_reloc hi_reloc
;
3180 memset (&hi_reloc
, 0, sizeof (hi_reloc
));
3181 switch (ELFNN_R_TYPE (rel
->r_info
))
3183 case R_RISCV_PCREL_LO12_I
:
3184 case R_RISCV_PCREL_LO12_S
:
3186 riscv_pcgp_hi_reloc
*hi
= riscv_find_pcgp_hi_reloc (pcgp_relocs
,
3187 symval
- sec_addr(sym_sec
));
3190 riscv_record_pcgp_lo_reloc (pcgp_relocs
, symval
- sec_addr(sym_sec
));
3195 symval
= hi_reloc
.hi_addr
;
3196 sym_sec
= hi_reloc
.sym_sec
;
3197 if (!riscv_use_pcgp_hi_reloc(pcgp_relocs
, hi
->hi_sec_off
))
3199 (_("%pB(%pA+%#" PRIx64
"): Unable to clear RISCV_PCREL_HI20 reloc "
3200 "for corresponding RISCV_PCREL_LO12 reloc"),
3201 abfd
, sec
, (uint64_t) rel
->r_offset
);
3205 case R_RISCV_PCREL_HI20
:
3206 /* Mergeable symbols and code might later move out of range. */
3207 if (sym_sec
->flags
& (SEC_MERGE
| SEC_CODE
))
3210 /* If the cooresponding lo relocation has already been seen then it's not
3211 * safe to relax this relocation. */
3212 if (riscv_find_pcgp_lo_reloc (pcgp_relocs
, rel
->r_offset
))
3223 /* If gp and the symbol are in the same output section, then
3224 consider only that section's alignment. */
3225 struct bfd_link_hash_entry
*h
=
3226 bfd_link_hash_lookup (link_info
->hash
, RISCV_GP_SYMBOL
, FALSE
, FALSE
, TRUE
);
3227 if (h
->u
.def
.section
->output_section
== sym_sec
->output_section
)
3228 max_alignment
= (bfd_vma
) 1 << sym_sec
->output_section
->alignment_power
;
3231 /* Is the reference in range of x0 or gp?
3232 Valid gp range conservatively because of alignment issue. */
3233 if (VALID_ITYPE_IMM (symval
)
3235 && VALID_ITYPE_IMM (symval
- gp
+ max_alignment
+ reserve_size
))
3237 && VALID_ITYPE_IMM (symval
- gp
- max_alignment
- reserve_size
)))
3239 unsigned sym
= hi_reloc
.hi_sym
;
3240 switch (ELFNN_R_TYPE (rel
->r_info
))
3242 case R_RISCV_PCREL_LO12_I
:
3243 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_GPREL_I
);
3244 rel
->r_addend
+= hi_reloc
.hi_addend
;
3245 return riscv_delete_pcgp_lo_reloc (pcgp_relocs
, rel
->r_offset
, 4);
3247 case R_RISCV_PCREL_LO12_S
:
3248 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_GPREL_S
);
3249 rel
->r_addend
+= hi_reloc
.hi_addend
;
3250 return riscv_delete_pcgp_lo_reloc (pcgp_relocs
, rel
->r_offset
, 4);
3252 case R_RISCV_PCREL_HI20
:
3253 riscv_record_pcgp_hi_reloc (pcgp_relocs
,
3257 ELFNN_R_SYM(rel
->r_info
),
3259 /* We can delete the unnecessary AUIPC and reloc. */
3260 rel
->r_info
= ELFNN_R_INFO (0, R_RISCV_DELETE
);
3262 return riscv_delete_pcgp_hi_reloc (pcgp_relocs
, rel
->r_offset
);
3272 /* Relax PC-relative references to GP-relative references. */
3275 _bfd_riscv_relax_delete (bfd
*abfd
,
3277 asection
*sym_sec ATTRIBUTE_UNUSED
,
3278 struct bfd_link_info
*link_info
,
3279 Elf_Internal_Rela
*rel
,
3280 bfd_vma symval ATTRIBUTE_UNUSED
,
3281 bfd_vma max_alignment ATTRIBUTE_UNUSED
,
3282 bfd_vma reserve_size ATTRIBUTE_UNUSED
,
3283 bfd_boolean
*again ATTRIBUTE_UNUSED
,
3284 riscv_pcgp_relocs
*pcgp_relocs ATTRIBUTE_UNUSED
)
3286 if (!riscv_relax_delete_bytes(abfd
, sec
, rel
->r_offset
, rel
->r_addend
,
3289 rel
->r_info
= ELFNN_R_INFO(0, R_RISCV_NONE
);
3293 /* Relax a section. Pass 0 shortens code sequences unless disabled. Pass 1
3294 deletes the bytes that pass 0 made obselete. Pass 2, which cannot be
3295 disabled, handles code alignment directives. */
3298 _bfd_riscv_relax_section (bfd
*abfd
, asection
*sec
,
3299 struct bfd_link_info
*info
,
3302 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (abfd
);
3303 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
3304 struct bfd_elf_section_data
*data
= elf_section_data (sec
);
3305 Elf_Internal_Rela
*relocs
;
3306 bfd_boolean ret
= FALSE
;
3308 bfd_vma max_alignment
, reserve_size
= 0;
3309 riscv_pcgp_relocs pcgp_relocs
;
3313 if (bfd_link_relocatable (info
)
3315 || (sec
->flags
& SEC_RELOC
) == 0
3316 || sec
->reloc_count
== 0
3317 || (info
->disable_target_specific_optimizations
3318 && info
->relax_pass
== 0))
3321 riscv_init_pcgp_relocs (&pcgp_relocs
);
3323 /* Read this BFD's relocs if we haven't done so already. */
3325 relocs
= data
->relocs
;
3326 else if (!(relocs
= _bfd_elf_link_read_relocs (abfd
, sec
, NULL
, NULL
,
3327 info
->keep_memory
)))
3332 max_alignment
= htab
->max_alignment
;
3333 if (max_alignment
== (bfd_vma
) -1)
3335 max_alignment
= _bfd_riscv_get_max_alignment (sec
);
3336 htab
->max_alignment
= max_alignment
;
3340 max_alignment
= _bfd_riscv_get_max_alignment (sec
);
3342 /* Examine and consider relaxing each reloc. */
3343 for (i
= 0; i
< sec
->reloc_count
; i
++)
3346 Elf_Internal_Rela
*rel
= relocs
+ i
;
3347 relax_func_t relax_func
;
3348 int type
= ELFNN_R_TYPE (rel
->r_info
);
3352 if (info
->relax_pass
== 0)
3354 if (type
== R_RISCV_CALL
|| type
== R_RISCV_CALL_PLT
)
3355 relax_func
= _bfd_riscv_relax_call
;
3356 else if (type
== R_RISCV_HI20
3357 || type
== R_RISCV_LO12_I
3358 || type
== R_RISCV_LO12_S
)
3359 relax_func
= _bfd_riscv_relax_lui
;
3360 else if (!bfd_link_pic(info
)
3361 && (type
== R_RISCV_PCREL_HI20
3362 || type
== R_RISCV_PCREL_LO12_I
3363 || type
== R_RISCV_PCREL_LO12_S
))
3364 relax_func
= _bfd_riscv_relax_pc
;
3365 else if (type
== R_RISCV_TPREL_HI20
3366 || type
== R_RISCV_TPREL_ADD
3367 || type
== R_RISCV_TPREL_LO12_I
3368 || type
== R_RISCV_TPREL_LO12_S
)
3369 relax_func
= _bfd_riscv_relax_tls_le
;
3373 /* Only relax this reloc if it is paired with R_RISCV_RELAX. */
3374 if (i
== sec
->reloc_count
- 1
3375 || ELFNN_R_TYPE ((rel
+ 1)->r_info
) != R_RISCV_RELAX
3376 || rel
->r_offset
!= (rel
+ 1)->r_offset
)
3379 /* Skip over the R_RISCV_RELAX. */
3382 else if (info
->relax_pass
== 1 && type
== R_RISCV_DELETE
)
3383 relax_func
= _bfd_riscv_relax_delete
;
3384 else if (info
->relax_pass
== 2 && type
== R_RISCV_ALIGN
)
3385 relax_func
= _bfd_riscv_relax_align
;
3389 data
->relocs
= relocs
;
3391 /* Read this BFD's contents if we haven't done so already. */
3392 if (!data
->this_hdr
.contents
3393 && !bfd_malloc_and_get_section (abfd
, sec
, &data
->this_hdr
.contents
))
3396 /* Read this BFD's symbols if we haven't done so already. */
3397 if (symtab_hdr
->sh_info
!= 0
3398 && !symtab_hdr
->contents
3399 && !(symtab_hdr
->contents
=
3400 (unsigned char *) bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
3401 symtab_hdr
->sh_info
,
3402 0, NULL
, NULL
, NULL
)))
3405 /* Get the value of the symbol referred to by the reloc. */
3406 if (ELFNN_R_SYM (rel
->r_info
) < symtab_hdr
->sh_info
)
3408 /* A local symbol. */
3409 Elf_Internal_Sym
*isym
= ((Elf_Internal_Sym
*) symtab_hdr
->contents
3410 + ELFNN_R_SYM (rel
->r_info
));
3411 reserve_size
= (isym
->st_size
- rel
->r_addend
) > isym
->st_size
3412 ? 0 : isym
->st_size
- rel
->r_addend
;
3414 if (isym
->st_shndx
== SHN_UNDEF
)
3415 sym_sec
= sec
, symval
= sec_addr (sec
) + rel
->r_offset
;
3418 BFD_ASSERT (isym
->st_shndx
< elf_numsections (abfd
));
3419 sym_sec
= elf_elfsections (abfd
)[isym
->st_shndx
]->bfd_section
;
3421 /* The purpose of this code is unknown. It breaks linker scripts
3422 for embedded development that place sections at address zero.
3423 This code is believed to be unnecessary. Disabling it but not
3424 yet removing it, in case something breaks. */
3425 if (sec_addr (sym_sec
) == 0)
3428 symval
= sec_addr (sym_sec
) + isym
->st_value
;
3434 struct elf_link_hash_entry
*h
;
3436 indx
= ELFNN_R_SYM (rel
->r_info
) - symtab_hdr
->sh_info
;
3437 h
= elf_sym_hashes (abfd
)[indx
];
3439 while (h
->root
.type
== bfd_link_hash_indirect
3440 || h
->root
.type
== bfd_link_hash_warning
)
3441 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3443 if (h
->plt
.offset
!= MINUS_ONE
)
3444 symval
= sec_addr (htab
->elf
.splt
) + h
->plt
.offset
;
3445 else if (h
->root
.u
.def
.section
->output_section
== NULL
3446 || (h
->root
.type
!= bfd_link_hash_defined
3447 && h
->root
.type
!= bfd_link_hash_defweak
))
3450 symval
= sec_addr (h
->root
.u
.def
.section
) + h
->root
.u
.def
.value
;
3452 if (h
->type
!= STT_FUNC
)
3454 (h
->size
- rel
->r_addend
) > h
->size
? 0 : h
->size
- rel
->r_addend
;
3455 sym_sec
= h
->root
.u
.def
.section
;
3458 symval
+= rel
->r_addend
;
3460 if (!relax_func (abfd
, sec
, sym_sec
, info
, rel
, symval
,
3461 max_alignment
, reserve_size
, again
,
3469 if (relocs
!= data
->relocs
)
3471 riscv_free_pcgp_relocs(&pcgp_relocs
, abfd
, sec
);
3477 # define PRSTATUS_SIZE 0 /* FIXME */
3478 # define PRSTATUS_OFFSET_PR_CURSIG 12
3479 # define PRSTATUS_OFFSET_PR_PID 24
3480 # define PRSTATUS_OFFSET_PR_REG 72
3481 # define ELF_GREGSET_T_SIZE 128
3482 # define PRPSINFO_SIZE 128
3483 # define PRPSINFO_OFFSET_PR_PID 16
3484 # define PRPSINFO_OFFSET_PR_FNAME 32
3485 # define PRPSINFO_OFFSET_PR_PSARGS 48
3487 # define PRSTATUS_SIZE 376
3488 # define PRSTATUS_OFFSET_PR_CURSIG 12
3489 # define PRSTATUS_OFFSET_PR_PID 32
3490 # define PRSTATUS_OFFSET_PR_REG 112
3491 # define ELF_GREGSET_T_SIZE 256
3492 # define PRPSINFO_SIZE 136
3493 # define PRPSINFO_OFFSET_PR_PID 24
3494 # define PRPSINFO_OFFSET_PR_FNAME 40
3495 # define PRPSINFO_OFFSET_PR_PSARGS 56
3498 /* Support for core dump NOTE sections. */
3501 riscv_elf_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
3503 switch (note
->descsz
)
3508 case PRSTATUS_SIZE
: /* sizeof(struct elf_prstatus) on Linux/RISC-V. */
3510 elf_tdata (abfd
)->core
->signal
3511 = bfd_get_16 (abfd
, note
->descdata
+ PRSTATUS_OFFSET_PR_CURSIG
);
3514 elf_tdata (abfd
)->core
->lwpid
3515 = bfd_get_32 (abfd
, note
->descdata
+ PRSTATUS_OFFSET_PR_PID
);
3519 /* Make a ".reg/999" section. */
3520 return _bfd_elfcore_make_pseudosection (abfd
, ".reg", ELF_GREGSET_T_SIZE
,
3521 note
->descpos
+ PRSTATUS_OFFSET_PR_REG
);
3525 riscv_elf_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
3527 switch (note
->descsz
)
3532 case PRPSINFO_SIZE
: /* sizeof(struct elf_prpsinfo) on Linux/RISC-V. */
3534 elf_tdata (abfd
)->core
->pid
3535 = bfd_get_32 (abfd
, note
->descdata
+ PRPSINFO_OFFSET_PR_PID
);
3538 elf_tdata (abfd
)->core
->program
= _bfd_elfcore_strndup
3539 (abfd
, note
->descdata
+ PRPSINFO_OFFSET_PR_FNAME
, 16);
3542 elf_tdata (abfd
)->core
->command
= _bfd_elfcore_strndup
3543 (abfd
, note
->descdata
+ PRPSINFO_OFFSET_PR_PSARGS
, 80);
3547 /* Note that for some reason, a spurious space is tacked
3548 onto the end of the args in some (at least one anyway)
3549 implementations, so strip it off if it exists. */
3552 char *command
= elf_tdata (abfd
)->core
->command
;
3553 int n
= strlen (command
);
3555 if (0 < n
&& command
[n
- 1] == ' ')
3556 command
[n
- 1] = '\0';
3562 /* Set the right mach type. */
3564 riscv_elf_object_p (bfd
*abfd
)
3566 /* There are only two mach types in RISCV currently. */
3567 if (strcmp (abfd
->xvec
->name
, "elf32-littleriscv") == 0)
3568 bfd_default_set_arch_mach (abfd
, bfd_arch_riscv
, bfd_mach_riscv32
);
3570 bfd_default_set_arch_mach (abfd
, bfd_arch_riscv
, bfd_mach_riscv64
);
3576 #define TARGET_LITTLE_SYM riscv_elfNN_vec
3577 #define TARGET_LITTLE_NAME "elfNN-littleriscv"
3579 #define elf_backend_reloc_type_class riscv_reloc_type_class
3581 #define bfd_elfNN_bfd_reloc_name_lookup riscv_reloc_name_lookup
3582 #define bfd_elfNN_bfd_link_hash_table_create riscv_elf_link_hash_table_create
3583 #define bfd_elfNN_bfd_reloc_type_lookup riscv_reloc_type_lookup
3584 #define bfd_elfNN_bfd_merge_private_bfd_data \
3585 _bfd_riscv_elf_merge_private_bfd_data
3587 #define elf_backend_copy_indirect_symbol riscv_elf_copy_indirect_symbol
3588 #define elf_backend_create_dynamic_sections riscv_elf_create_dynamic_sections
3589 #define elf_backend_check_relocs riscv_elf_check_relocs
3590 #define elf_backend_adjust_dynamic_symbol riscv_elf_adjust_dynamic_symbol
3591 #define elf_backend_size_dynamic_sections riscv_elf_size_dynamic_sections
3592 #define elf_backend_relocate_section riscv_elf_relocate_section
3593 #define elf_backend_finish_dynamic_symbol riscv_elf_finish_dynamic_symbol
3594 #define elf_backend_finish_dynamic_sections riscv_elf_finish_dynamic_sections
3595 #define elf_backend_gc_mark_hook riscv_elf_gc_mark_hook
3596 #define elf_backend_plt_sym_val riscv_elf_plt_sym_val
3597 #define elf_backend_grok_prstatus riscv_elf_grok_prstatus
3598 #define elf_backend_grok_psinfo riscv_elf_grok_psinfo
3599 #define elf_backend_object_p riscv_elf_object_p
3600 #define elf_info_to_howto_rel NULL
3601 #define elf_info_to_howto riscv_info_to_howto_rela
3602 #define bfd_elfNN_bfd_relax_section _bfd_riscv_relax_section
3604 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
3606 #define elf_backend_can_gc_sections 1
3607 #define elf_backend_can_refcount 1
3608 #define elf_backend_want_got_plt 1
3609 #define elf_backend_plt_readonly 1
3610 #define elf_backend_plt_alignment 4
3611 #define elf_backend_want_plt_sym 1
3612 #define elf_backend_got_header_size (ARCH_SIZE / 8)
3613 #define elf_backend_want_dynrelro 1
3614 #define elf_backend_rela_normal 1
3615 #define elf_backend_default_execstack 0
3617 #include "elfNN-target.h"