1 /* RISC-V-specific support for NN-bit ELF.
2 Copyright (C) 2011-2020 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
*output_bfd
, bfd_vma gotplt_addr
, bfd_vma addr
,
176 bfd_vma gotplt_offset_high
= RISCV_PCREL_HIGH_PART (gotplt_addr
, addr
);
177 bfd_vma gotplt_offset_low
= RISCV_PCREL_LOW_PART (gotplt_addr
, addr
);
179 /* RVE has no t3 register, so this won't work, and is not supported. */
180 if (elf_elfheader (output_bfd
)->e_flags
& EF_RISCV_RVE
)
182 _bfd_error_handler (_("%pB: warning: RVE PLT generation not supported"),
187 /* auipc t2, %hi(.got.plt)
188 sub t1, t1, t3 # shifted .got.plt offset + hdr size + 12
189 l[w|d] t3, %lo(.got.plt)(t2) # _dl_runtime_resolve
190 addi t1, t1, -(hdr size + 12) # shifted .got.plt offset
191 addi t0, t2, %lo(.got.plt) # &.got.plt
192 srli t1, t1, log2(16/PTRSIZE) # .got.plt offset
193 l[w|d] t0, PTRSIZE(t0) # link map
196 entry
[0] = RISCV_UTYPE (AUIPC
, X_T2
, gotplt_offset_high
);
197 entry
[1] = RISCV_RTYPE (SUB
, X_T1
, X_T1
, X_T3
);
198 entry
[2] = RISCV_ITYPE (LREG
, X_T3
, X_T2
, gotplt_offset_low
);
199 entry
[3] = RISCV_ITYPE (ADDI
, X_T1
, X_T1
, -(PLT_HEADER_SIZE
+ 12));
200 entry
[4] = RISCV_ITYPE (ADDI
, X_T0
, X_T2
, gotplt_offset_low
);
201 entry
[5] = RISCV_ITYPE (SRLI
, X_T1
, X_T1
, 4 - RISCV_ELF_LOG_WORD_BYTES
);
202 entry
[6] = RISCV_ITYPE (LREG
, X_T0
, X_T0
, RISCV_ELF_WORD_BYTES
);
203 entry
[7] = RISCV_ITYPE (JALR
, 0, X_T3
, 0);
208 /* Generate a PLT entry. */
211 riscv_make_plt_entry (bfd
*output_bfd
, bfd_vma got
, bfd_vma addr
,
214 /* RVE has no t3 register, so this won't work, and is not supported. */
215 if (elf_elfheader (output_bfd
)->e_flags
& EF_RISCV_RVE
)
217 _bfd_error_handler (_("%pB: warning: RVE PLT generation not supported"),
222 /* auipc t3, %hi(.got.plt entry)
223 l[w|d] t3, %lo(.got.plt entry)(t3)
227 entry
[0] = RISCV_UTYPE (AUIPC
, X_T3
, RISCV_PCREL_HIGH_PART (got
, addr
));
228 entry
[1] = RISCV_ITYPE (LREG
, X_T3
, X_T3
, RISCV_PCREL_LOW_PART (got
, addr
));
229 entry
[2] = RISCV_ITYPE (JALR
, X_T1
, X_T3
, 0);
230 entry
[3] = RISCV_NOP
;
235 /* Create an entry in an RISC-V ELF linker hash table. */
237 static struct bfd_hash_entry
*
238 link_hash_newfunc (struct bfd_hash_entry
*entry
,
239 struct bfd_hash_table
*table
, const char *string
)
241 /* Allocate the structure if it has not already been allocated by a
246 bfd_hash_allocate (table
,
247 sizeof (struct riscv_elf_link_hash_entry
));
252 /* Call the allocation method of the superclass. */
253 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
256 struct riscv_elf_link_hash_entry
*eh
;
258 eh
= (struct riscv_elf_link_hash_entry
*) entry
;
259 eh
->dyn_relocs
= NULL
;
260 eh
->tls_type
= GOT_UNKNOWN
;
266 /* Create a RISC-V ELF linker hash table. */
268 static struct bfd_link_hash_table
*
269 riscv_elf_link_hash_table_create (bfd
*abfd
)
271 struct riscv_elf_link_hash_table
*ret
;
272 size_t amt
= sizeof (struct riscv_elf_link_hash_table
);
274 ret
= (struct riscv_elf_link_hash_table
*) bfd_zmalloc (amt
);
278 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
, link_hash_newfunc
,
279 sizeof (struct riscv_elf_link_hash_entry
),
286 ret
->max_alignment
= (bfd_vma
) -1;
287 return &ret
->elf
.root
;
290 /* Create the .got section. */
293 riscv_elf_create_got_section (bfd
*abfd
, struct bfd_link_info
*info
)
297 struct elf_link_hash_entry
*h
;
298 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
299 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
301 /* This function may be called more than once. */
302 if (htab
->sgot
!= NULL
)
305 flags
= bed
->dynamic_sec_flags
;
307 s
= bfd_make_section_anyway_with_flags (abfd
,
308 (bed
->rela_plts_and_copies_p
309 ? ".rela.got" : ".rel.got"),
310 (bed
->dynamic_sec_flags
313 || !bfd_set_section_alignment (s
, bed
->s
->log_file_align
))
317 s
= s_got
= bfd_make_section_anyway_with_flags (abfd
, ".got", flags
);
319 || !bfd_set_section_alignment (s
, bed
->s
->log_file_align
))
323 /* The first bit of the global offset table is the header. */
324 s
->size
+= bed
->got_header_size
;
326 if (bed
->want_got_plt
)
328 s
= bfd_make_section_anyway_with_flags (abfd
, ".got.plt", flags
);
330 || !bfd_set_section_alignment (s
, bed
->s
->log_file_align
))
334 /* Reserve room for the header. */
335 s
->size
+= GOTPLT_HEADER_SIZE
;
338 if (bed
->want_got_sym
)
340 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
341 section. We don't do this in the linker script because we don't want
342 to define the symbol if we are not creating a global offset
344 h
= _bfd_elf_define_linkage_sym (abfd
, info
, s_got
,
345 "_GLOBAL_OFFSET_TABLE_");
346 elf_hash_table (info
)->hgot
= h
;
354 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
355 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
359 riscv_elf_create_dynamic_sections (bfd
*dynobj
,
360 struct bfd_link_info
*info
)
362 struct riscv_elf_link_hash_table
*htab
;
364 htab
= riscv_elf_hash_table (info
);
365 BFD_ASSERT (htab
!= NULL
);
367 if (!riscv_elf_create_got_section (dynobj
, info
))
370 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
373 if (!bfd_link_pic (info
))
375 /* Technically, this section doesn't have contents. It is used as the
376 target of TLS copy relocs, to copy TLS data from shared libraries into
377 the executable. However, if we don't mark it as loadable, then it
378 matches the IS_TBSS test in ldlang.c, and there is no run-time address
379 space allocated for it even though it has SEC_ALLOC. That test is
380 correct for .tbss, but not correct for this section. There is also
381 a second problem that having a section with no contents can only work
382 if it comes after all sections with contents in the same segment,
383 but the linker script does not guarantee that. This is just mixed in
384 with other .tdata.* sections. We can fix both problems by lying and
385 saying that there are contents. This section is expected to be small
386 so this should not cause a significant extra program startup cost. */
388 bfd_make_section_anyway_with_flags (dynobj
, ".tdata.dyn",
389 (SEC_ALLOC
| SEC_THREAD_LOCAL
390 | SEC_LOAD
| SEC_DATA
392 | SEC_LINKER_CREATED
));
395 if (!htab
->elf
.splt
|| !htab
->elf
.srelplt
|| !htab
->elf
.sdynbss
396 || (!bfd_link_pic (info
) && (!htab
->elf
.srelbss
|| !htab
->sdyntdata
)))
402 /* Copy the extra info we tack onto an elf_link_hash_entry. */
405 riscv_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
406 struct elf_link_hash_entry
*dir
,
407 struct elf_link_hash_entry
*ind
)
409 struct riscv_elf_link_hash_entry
*edir
, *eind
;
411 edir
= (struct riscv_elf_link_hash_entry
*) dir
;
412 eind
= (struct riscv_elf_link_hash_entry
*) ind
;
414 if (eind
->dyn_relocs
!= NULL
)
416 if (edir
->dyn_relocs
!= NULL
)
418 struct elf_dyn_relocs
**pp
;
419 struct elf_dyn_relocs
*p
;
421 /* Add reloc counts against the indirect sym to the direct sym
422 list. Merge any entries against the same section. */
423 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
425 struct elf_dyn_relocs
*q
;
427 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
428 if (q
->sec
== p
->sec
)
430 q
->pc_count
+= p
->pc_count
;
431 q
->count
+= p
->count
;
438 *pp
= edir
->dyn_relocs
;
441 edir
->dyn_relocs
= eind
->dyn_relocs
;
442 eind
->dyn_relocs
= NULL
;
445 if (ind
->root
.type
== bfd_link_hash_indirect
446 && dir
->got
.refcount
<= 0)
448 edir
->tls_type
= eind
->tls_type
;
449 eind
->tls_type
= GOT_UNKNOWN
;
451 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
455 riscv_elf_record_tls_type (bfd
*abfd
, struct elf_link_hash_entry
*h
,
456 unsigned long symndx
, char tls_type
)
458 char *new_tls_type
= &_bfd_riscv_elf_tls_type (abfd
, h
, symndx
);
460 *new_tls_type
|= tls_type
;
461 if ((*new_tls_type
& GOT_NORMAL
) && (*new_tls_type
& ~GOT_NORMAL
))
463 (*_bfd_error_handler
)
464 (_("%pB: `%s' accessed both as normal and thread local symbol"),
465 abfd
, h
? h
->root
.root
.string
: "<local>");
472 riscv_elf_record_got_reference (bfd
*abfd
, struct bfd_link_info
*info
,
473 struct elf_link_hash_entry
*h
, long symndx
)
475 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
476 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
478 if (htab
->elf
.sgot
== NULL
)
480 if (!riscv_elf_create_got_section (htab
->elf
.dynobj
, info
))
486 h
->got
.refcount
+= 1;
490 /* This is a global offset table entry for a local symbol. */
491 if (elf_local_got_refcounts (abfd
) == NULL
)
493 bfd_size_type size
= symtab_hdr
->sh_info
* (sizeof (bfd_vma
) + 1);
494 if (!(elf_local_got_refcounts (abfd
) = bfd_zalloc (abfd
, size
)))
496 _bfd_riscv_elf_local_got_tls_type (abfd
)
497 = (char *) (elf_local_got_refcounts (abfd
) + symtab_hdr
->sh_info
);
499 elf_local_got_refcounts (abfd
) [symndx
] += 1;
505 bad_static_reloc (bfd
*abfd
, unsigned r_type
, struct elf_link_hash_entry
*h
)
507 reloc_howto_type
* r
= riscv_elf_rtype_to_howto (abfd
, r_type
);
509 (*_bfd_error_handler
)
510 (_("%pB: relocation %s against `%s' can not be used when making a shared "
511 "object; recompile with -fPIC"),
512 abfd
, r
? r
->name
: _("<unknown>"),
513 h
!= NULL
? h
->root
.root
.string
: "a local symbol");
514 bfd_set_error (bfd_error_bad_value
);
517 /* Look through the relocs for a section during the first phase, and
518 allocate space in the global offset table or procedure linkage
522 riscv_elf_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
523 asection
*sec
, const Elf_Internal_Rela
*relocs
)
525 struct riscv_elf_link_hash_table
*htab
;
526 Elf_Internal_Shdr
*symtab_hdr
;
527 struct elf_link_hash_entry
**sym_hashes
;
528 const Elf_Internal_Rela
*rel
;
529 asection
*sreloc
= NULL
;
531 if (bfd_link_relocatable (info
))
534 htab
= riscv_elf_hash_table (info
);
535 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
536 sym_hashes
= elf_sym_hashes (abfd
);
538 if (htab
->elf
.dynobj
== NULL
)
539 htab
->elf
.dynobj
= abfd
;
541 for (rel
= relocs
; rel
< relocs
+ sec
->reloc_count
; rel
++)
544 unsigned int r_symndx
;
545 struct elf_link_hash_entry
*h
;
547 r_symndx
= ELFNN_R_SYM (rel
->r_info
);
548 r_type
= ELFNN_R_TYPE (rel
->r_info
);
550 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
552 (*_bfd_error_handler
) (_("%pB: bad symbol index: %d"),
557 if (r_symndx
< symtab_hdr
->sh_info
)
561 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
562 while (h
->root
.type
== bfd_link_hash_indirect
563 || h
->root
.type
== bfd_link_hash_warning
)
564 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
569 case R_RISCV_TLS_GD_HI20
:
570 if (!riscv_elf_record_got_reference (abfd
, info
, h
, r_symndx
)
571 || !riscv_elf_record_tls_type (abfd
, h
, r_symndx
, GOT_TLS_GD
))
575 case R_RISCV_TLS_GOT_HI20
:
576 if (bfd_link_pic (info
))
577 info
->flags
|= DF_STATIC_TLS
;
578 if (!riscv_elf_record_got_reference (abfd
, info
, h
, r_symndx
)
579 || !riscv_elf_record_tls_type (abfd
, h
, r_symndx
, GOT_TLS_IE
))
583 case R_RISCV_GOT_HI20
:
584 if (!riscv_elf_record_got_reference (abfd
, info
, h
, r_symndx
)
585 || !riscv_elf_record_tls_type (abfd
, h
, r_symndx
, GOT_NORMAL
))
589 case R_RISCV_CALL_PLT
:
590 /* This symbol requires a procedure linkage table entry. We
591 actually build the entry in adjust_dynamic_symbol,
592 because this might be a case of linking PIC code without
593 linking in any dynamic objects, in which case we don't
594 need to generate a procedure linkage table after all. */
599 h
->plt
.refcount
+= 1;
606 case R_RISCV_RVC_BRANCH
:
607 case R_RISCV_RVC_JUMP
:
608 case R_RISCV_PCREL_HI20
:
609 /* In shared libraries, these relocs are known to bind locally. */
610 if (bfd_link_pic (info
))
614 case R_RISCV_TPREL_HI20
:
615 if (!bfd_link_executable (info
))
616 return bad_static_reloc (abfd
, r_type
, h
);
618 riscv_elf_record_tls_type (abfd
, h
, r_symndx
, GOT_TLS_LE
);
622 if (bfd_link_pic (info
))
623 return bad_static_reloc (abfd
, r_type
, h
);
627 case R_RISCV_JUMP_SLOT
:
628 case R_RISCV_RELATIVE
:
634 /* This reloc might not bind locally. */
638 if (h
!= NULL
&& !bfd_link_pic (info
))
640 /* We may need a .plt entry if the function this reloc
641 refers to is in a shared lib. */
642 h
->plt
.refcount
+= 1;
645 /* If we are creating a shared library, and this is a reloc
646 against a global symbol, or a non PC relative reloc
647 against a local symbol, then we need to copy the reloc
648 into the shared library. However, if we are linking with
649 -Bsymbolic, we do not need to copy a reloc against a
650 global symbol which is defined in an object we are
651 including in the link (i.e., DEF_REGULAR is set). At
652 this point we have not seen all the input files, so it is
653 possible that DEF_REGULAR is not set now but will be set
654 later (it is never cleared). In case of a weak definition,
655 DEF_REGULAR may be cleared later by a strong definition in
656 a shared library. We account for that possibility below by
657 storing information in the relocs_copied field of the hash
658 table entry. A similar situation occurs when creating
659 shared libraries and symbol visibility changes render the
662 If on the other hand, we are creating an executable, we
663 may need to keep relocations for symbols satisfied by a
664 dynamic library if we manage to avoid copy relocs for the
666 reloc_howto_type
* r
= riscv_elf_rtype_to_howto (abfd
, r_type
);
668 if ((bfd_link_pic (info
)
669 && (sec
->flags
& SEC_ALLOC
) != 0
670 && ((r
!= NULL
&& ! r
->pc_relative
)
673 || h
->root
.type
== bfd_link_hash_defweak
674 || !h
->def_regular
))))
675 || (!bfd_link_pic (info
)
676 && (sec
->flags
& SEC_ALLOC
) != 0
678 && (h
->root
.type
== bfd_link_hash_defweak
679 || !h
->def_regular
)))
681 struct elf_dyn_relocs
*p
;
682 struct elf_dyn_relocs
**head
;
684 /* When creating a shared object, we must copy these
685 relocs into the output file. We create a reloc
686 section in dynobj and make room for the reloc. */
689 sreloc
= _bfd_elf_make_dynamic_reloc_section
690 (sec
, htab
->elf
.dynobj
, RISCV_ELF_LOG_WORD_BYTES
,
691 abfd
, /*rela?*/ TRUE
);
697 /* If this is a global symbol, we count the number of
698 relocations we need for this symbol. */
700 head
= &((struct riscv_elf_link_hash_entry
*) h
)->dyn_relocs
;
703 /* Track dynamic relocs needed for local syms too.
704 We really need local syms available to do this
709 Elf_Internal_Sym
*isym
;
711 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
716 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
720 vpp
= &elf_section_data (s
)->local_dynrel
;
721 head
= (struct elf_dyn_relocs
**) vpp
;
725 if (p
== NULL
|| p
->sec
!= sec
)
727 size_t amt
= sizeof *p
;
728 p
= ((struct elf_dyn_relocs
*)
729 bfd_alloc (htab
->elf
.dynobj
, amt
));
740 p
->pc_count
+= r
== NULL
? 0 : r
->pc_relative
;
745 case R_RISCV_GNU_VTINHERIT
:
746 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
750 case R_RISCV_GNU_VTENTRY
:
751 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
764 riscv_elf_gc_mark_hook (asection
*sec
,
765 struct bfd_link_info
*info
,
766 Elf_Internal_Rela
*rel
,
767 struct elf_link_hash_entry
*h
,
768 Elf_Internal_Sym
*sym
)
771 switch (ELFNN_R_TYPE (rel
->r_info
))
773 case R_RISCV_GNU_VTINHERIT
:
774 case R_RISCV_GNU_VTENTRY
:
778 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
781 /* Find dynamic relocs for H that apply to read-only sections. */
784 readonly_dynrelocs (struct elf_link_hash_entry
*h
)
786 struct elf_dyn_relocs
*p
;
788 for (p
= riscv_elf_hash_entry (h
)->dyn_relocs
; p
!= NULL
; p
= p
->next
)
790 asection
*s
= p
->sec
->output_section
;
792 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
798 /* Adjust a symbol defined by a dynamic object and referenced by a
799 regular object. The current definition is in some section of the
800 dynamic object, but we're not including those sections. We have to
801 change the definition to something the rest of the link can
805 riscv_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
806 struct elf_link_hash_entry
*h
)
808 struct riscv_elf_link_hash_table
*htab
;
809 struct riscv_elf_link_hash_entry
* eh
;
813 htab
= riscv_elf_hash_table (info
);
814 BFD_ASSERT (htab
!= NULL
);
816 dynobj
= htab
->elf
.dynobj
;
818 /* Make sure we know what is going on here. */
819 BFD_ASSERT (dynobj
!= NULL
821 || h
->type
== STT_GNU_IFUNC
825 && !h
->def_regular
)));
827 /* If this is a function, put it in the procedure linkage table. We
828 will fill in the contents of the procedure linkage table later
829 (although we could actually do it here). */
830 if (h
->type
== STT_FUNC
|| h
->type
== STT_GNU_IFUNC
|| h
->needs_plt
)
832 if (h
->plt
.refcount
<= 0
833 || SYMBOL_CALLS_LOCAL (info
, h
)
834 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
835 && h
->root
.type
== bfd_link_hash_undefweak
))
837 /* This case can occur if we saw a R_RISCV_CALL_PLT reloc in an
838 input file, but the symbol was never referred to by a dynamic
839 object, or if all references were garbage collected. In such
840 a case, we don't actually need to build a PLT entry. */
841 h
->plt
.offset
= (bfd_vma
) -1;
848 h
->plt
.offset
= (bfd_vma
) -1;
850 /* If this is a weak symbol, and there is a real definition, the
851 processor independent code will have arranged for us to see the
852 real definition first, and we can just use the same value. */
855 struct elf_link_hash_entry
*def
= weakdef (h
);
856 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
857 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
858 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
862 /* This is a reference to a symbol defined by a dynamic object which
863 is not a function. */
865 /* If we are creating a shared library, we must presume that the
866 only references to the symbol are via the global offset table.
867 For such cases we need not do anything here; the relocations will
868 be handled correctly by relocate_section. */
869 if (bfd_link_pic (info
))
872 /* If there are no references to this symbol that do not use the
873 GOT, we don't need to generate a copy reloc. */
877 /* If -z nocopyreloc was given, we won't generate them either. */
878 if (info
->nocopyreloc
)
884 /* If we don't find any dynamic relocs in read-only sections, then
885 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
886 if (!readonly_dynrelocs (h
))
892 /* We must allocate the symbol in our .dynbss section, which will
893 become part of the .bss section of the executable. There will be
894 an entry for this symbol in the .dynsym section. The dynamic
895 object will contain position independent code, so all references
896 from the dynamic object to this symbol will go through the global
897 offset table. The dynamic linker will use the .dynsym entry to
898 determine the address it must put in the global offset table, so
899 both the dynamic object and the regular object will refer to the
900 same memory location for the variable. */
902 /* We must generate a R_RISCV_COPY reloc to tell the dynamic linker
903 to copy the initial value out of the dynamic object and into the
904 runtime process image. We need to remember the offset into the
905 .rel.bss section we are going to use. */
906 eh
= (struct riscv_elf_link_hash_entry
*) h
;
907 if (eh
->tls_type
& ~GOT_NORMAL
)
910 srel
= htab
->elf
.srelbss
;
912 else if ((h
->root
.u
.def
.section
->flags
& SEC_READONLY
) != 0)
914 s
= htab
->elf
.sdynrelro
;
915 srel
= htab
->elf
.sreldynrelro
;
919 s
= htab
->elf
.sdynbss
;
920 srel
= htab
->elf
.srelbss
;
922 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
924 srel
->size
+= sizeof (ElfNN_External_Rela
);
928 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
931 /* Allocate space in .plt, .got and associated reloc sections for
935 allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
937 struct bfd_link_info
*info
;
938 struct riscv_elf_link_hash_table
*htab
;
939 struct riscv_elf_link_hash_entry
*eh
;
940 struct elf_dyn_relocs
*p
;
942 if (h
->root
.type
== bfd_link_hash_indirect
)
945 info
= (struct bfd_link_info
*) inf
;
946 htab
= riscv_elf_hash_table (info
);
947 BFD_ASSERT (htab
!= NULL
);
949 if (htab
->elf
.dynamic_sections_created
950 && h
->plt
.refcount
> 0)
952 /* Make sure this symbol is output as a dynamic symbol.
953 Undefined weak syms won't yet be marked as dynamic. */
957 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
961 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info
), h
))
963 asection
*s
= htab
->elf
.splt
;
966 s
->size
= PLT_HEADER_SIZE
;
968 h
->plt
.offset
= s
->size
;
970 /* Make room for this entry. */
971 s
->size
+= PLT_ENTRY_SIZE
;
973 /* We also need to make an entry in the .got.plt section. */
974 htab
->elf
.sgotplt
->size
+= GOT_ENTRY_SIZE
;
976 /* We also need to make an entry in the .rela.plt section. */
977 htab
->elf
.srelplt
->size
+= sizeof (ElfNN_External_Rela
);
979 /* If this symbol is not defined in a regular file, and we are
980 not generating a shared library, then set the symbol to this
981 location in the .plt. This is required to make function
982 pointers compare as equal between the normal executable and
983 the shared library. */
984 if (! bfd_link_pic (info
)
987 h
->root
.u
.def
.section
= s
;
988 h
->root
.u
.def
.value
= h
->plt
.offset
;
993 h
->plt
.offset
= (bfd_vma
) -1;
999 h
->plt
.offset
= (bfd_vma
) -1;
1003 if (h
->got
.refcount
> 0)
1007 int tls_type
= riscv_elf_hash_entry (h
)->tls_type
;
1009 /* Make sure this symbol is output as a dynamic symbol.
1010 Undefined weak syms won't yet be marked as dynamic. */
1011 if (h
->dynindx
== -1
1012 && !h
->forced_local
)
1014 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1019 h
->got
.offset
= s
->size
;
1020 dyn
= htab
->elf
.dynamic_sections_created
;
1021 if (tls_type
& (GOT_TLS_GD
| GOT_TLS_IE
))
1023 /* TLS_GD needs two dynamic relocs and two GOT slots. */
1024 if (tls_type
& GOT_TLS_GD
)
1026 s
->size
+= 2 * RISCV_ELF_WORD_BYTES
;
1027 htab
->elf
.srelgot
->size
+= 2 * sizeof (ElfNN_External_Rela
);
1030 /* TLS_IE needs one dynamic reloc and one GOT slot. */
1031 if (tls_type
& GOT_TLS_IE
)
1033 s
->size
+= RISCV_ELF_WORD_BYTES
;
1034 htab
->elf
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
1039 s
->size
+= RISCV_ELF_WORD_BYTES
;
1040 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, bfd_link_pic (info
), h
)
1041 && ! UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
1042 htab
->elf
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
1046 h
->got
.offset
= (bfd_vma
) -1;
1048 eh
= (struct riscv_elf_link_hash_entry
*) h
;
1049 if (eh
->dyn_relocs
== NULL
)
1052 /* In the shared -Bsymbolic case, discard space allocated for
1053 dynamic pc-relative relocs against symbols which turn out to be
1054 defined in regular objects. For the normal shared case, discard
1055 space for pc-relative relocs that have become local due to symbol
1056 visibility changes. */
1058 if (bfd_link_pic (info
))
1060 if (SYMBOL_CALLS_LOCAL (info
, h
))
1062 struct elf_dyn_relocs
**pp
;
1064 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
1066 p
->count
-= p
->pc_count
;
1075 /* Also discard relocs on undefined weak syms with non-default
1077 if (eh
->dyn_relocs
!= NULL
1078 && h
->root
.type
== bfd_link_hash_undefweak
)
1080 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
1081 || UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
1082 eh
->dyn_relocs
= NULL
;
1084 /* Make sure undefined weak symbols are output as a dynamic
1086 else if (h
->dynindx
== -1
1087 && !h
->forced_local
)
1089 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1096 /* For the non-shared case, discard space for relocs against
1097 symbols which turn out to need copy relocs or are not
1103 || (htab
->elf
.dynamic_sections_created
1104 && (h
->root
.type
== bfd_link_hash_undefweak
1105 || h
->root
.type
== bfd_link_hash_undefined
))))
1107 /* Make sure this symbol is output as a dynamic symbol.
1108 Undefined weak syms won't yet be marked as dynamic. */
1109 if (h
->dynindx
== -1
1110 && !h
->forced_local
)
1112 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1116 /* If that succeeded, we know we'll be keeping all the
1118 if (h
->dynindx
!= -1)
1122 eh
->dyn_relocs
= NULL
;
1127 /* Finally, allocate space. */
1128 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1130 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
1131 sreloc
->size
+= p
->count
* sizeof (ElfNN_External_Rela
);
1137 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
1138 read-only sections. */
1141 maybe_set_textrel (struct elf_link_hash_entry
*h
, void *info_p
)
1145 if (h
->root
.type
== bfd_link_hash_indirect
)
1148 sec
= readonly_dynrelocs (h
);
1151 struct bfd_link_info
*info
= (struct bfd_link_info
*) info_p
;
1153 info
->flags
|= DF_TEXTREL
;
1154 info
->callbacks
->minfo
1155 (_("%pB: dynamic relocation against `%pT' in read-only section `%pA'\n"),
1156 sec
->owner
, h
->root
.root
.string
, sec
);
1158 /* Not an error, just cut short the traversal. */
1165 riscv_elf_size_dynamic_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
1167 struct riscv_elf_link_hash_table
*htab
;
1172 htab
= riscv_elf_hash_table (info
);
1173 BFD_ASSERT (htab
!= NULL
);
1174 dynobj
= htab
->elf
.dynobj
;
1175 BFD_ASSERT (dynobj
!= NULL
);
1177 if (elf_hash_table (info
)->dynamic_sections_created
)
1179 /* Set the contents of the .interp section to the interpreter. */
1180 if (bfd_link_executable (info
) && !info
->nointerp
)
1182 s
= bfd_get_linker_section (dynobj
, ".interp");
1183 BFD_ASSERT (s
!= NULL
);
1184 s
->size
= strlen (ELFNN_DYNAMIC_INTERPRETER
) + 1;
1185 s
->contents
= (unsigned char *) ELFNN_DYNAMIC_INTERPRETER
;
1189 /* Set up .got offsets for local syms, and space for local dynamic
1191 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
1193 bfd_signed_vma
*local_got
;
1194 bfd_signed_vma
*end_local_got
;
1195 char *local_tls_type
;
1196 bfd_size_type locsymcount
;
1197 Elf_Internal_Shdr
*symtab_hdr
;
1200 if (! is_riscv_elf (ibfd
))
1203 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
1205 struct elf_dyn_relocs
*p
;
1207 for (p
= elf_section_data (s
)->local_dynrel
; p
!= NULL
; p
= p
->next
)
1209 if (!bfd_is_abs_section (p
->sec
)
1210 && bfd_is_abs_section (p
->sec
->output_section
))
1212 /* Input section has been discarded, either because
1213 it is a copy of a linkonce section or due to
1214 linker script /DISCARD/, so we'll be discarding
1217 else if (p
->count
!= 0)
1219 srel
= elf_section_data (p
->sec
)->sreloc
;
1220 srel
->size
+= p
->count
* sizeof (ElfNN_External_Rela
);
1221 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
1222 info
->flags
|= DF_TEXTREL
;
1227 local_got
= elf_local_got_refcounts (ibfd
);
1231 symtab_hdr
= &elf_symtab_hdr (ibfd
);
1232 locsymcount
= symtab_hdr
->sh_info
;
1233 end_local_got
= local_got
+ locsymcount
;
1234 local_tls_type
= _bfd_riscv_elf_local_got_tls_type (ibfd
);
1236 srel
= htab
->elf
.srelgot
;
1237 for (; local_got
< end_local_got
; ++local_got
, ++local_tls_type
)
1241 *local_got
= s
->size
;
1242 s
->size
+= RISCV_ELF_WORD_BYTES
;
1243 if (*local_tls_type
& GOT_TLS_GD
)
1244 s
->size
+= RISCV_ELF_WORD_BYTES
;
1245 if (bfd_link_pic (info
)
1246 || (*local_tls_type
& (GOT_TLS_GD
| GOT_TLS_IE
)))
1247 srel
->size
+= sizeof (ElfNN_External_Rela
);
1250 *local_got
= (bfd_vma
) -1;
1254 /* Allocate global sym .plt and .got entries, and space for global
1255 sym dynamic relocs. */
1256 elf_link_hash_traverse (&htab
->elf
, allocate_dynrelocs
, info
);
1258 if (htab
->elf
.sgotplt
)
1260 struct elf_link_hash_entry
*got
;
1261 got
= elf_link_hash_lookup (elf_hash_table (info
),
1262 "_GLOBAL_OFFSET_TABLE_",
1263 FALSE
, FALSE
, FALSE
);
1265 /* Don't allocate .got.plt section if there are no GOT nor PLT
1266 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
1268 || !got
->ref_regular_nonweak
)
1269 && (htab
->elf
.sgotplt
->size
== GOTPLT_HEADER_SIZE
)
1270 && (htab
->elf
.splt
== NULL
1271 || htab
->elf
.splt
->size
== 0)
1272 && (htab
->elf
.sgot
== NULL
1273 || (htab
->elf
.sgot
->size
1274 == get_elf_backend_data (output_bfd
)->got_header_size
)))
1275 htab
->elf
.sgotplt
->size
= 0;
1278 /* The check_relocs and adjust_dynamic_symbol entry points have
1279 determined the sizes of the various dynamic sections. Allocate
1281 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1283 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1286 if (s
== htab
->elf
.splt
1287 || s
== htab
->elf
.sgot
1288 || s
== htab
->elf
.sgotplt
1289 || s
== htab
->elf
.sdynbss
1290 || s
== htab
->elf
.sdynrelro
1291 || s
== htab
->sdyntdata
)
1293 /* Strip this section if we don't need it; see the
1296 else if (strncmp (s
->name
, ".rela", 5) == 0)
1300 /* We use the reloc_count field as a counter if we need
1301 to copy relocs into the output file. */
1307 /* It's not one of our sections. */
1313 /* If we don't need this section, strip it from the
1314 output file. This is mostly to handle .rela.bss and
1315 .rela.plt. We must create both sections in
1316 create_dynamic_sections, because they must be created
1317 before the linker maps input sections to output
1318 sections. The linker does that before
1319 adjust_dynamic_symbol is called, and it is that
1320 function which decides whether anything needs to go
1321 into these sections. */
1322 s
->flags
|= SEC_EXCLUDE
;
1326 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
1329 /* Allocate memory for the section contents. Zero the memory
1330 for the benefit of .rela.plt, which has 4 unused entries
1331 at the beginning, and we don't want garbage. */
1332 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
1333 if (s
->contents
== NULL
)
1337 if (elf_hash_table (info
)->dynamic_sections_created
)
1339 /* Add some entries to the .dynamic section. We fill in the
1340 values later, in riscv_elf_finish_dynamic_sections, but we
1341 must add the entries now so that we get the correct size for
1342 the .dynamic section. The DT_DEBUG entry is filled in by the
1343 dynamic linker and used by the debugger. */
1344 #define add_dynamic_entry(TAG, VAL) \
1345 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1347 if (bfd_link_executable (info
))
1349 if (!add_dynamic_entry (DT_DEBUG
, 0))
1353 if (htab
->elf
.srelplt
->size
!= 0)
1355 if (!add_dynamic_entry (DT_PLTGOT
, 0)
1356 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
1357 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
1358 || !add_dynamic_entry (DT_JMPREL
, 0))
1362 if (!add_dynamic_entry (DT_RELA
, 0)
1363 || !add_dynamic_entry (DT_RELASZ
, 0)
1364 || !add_dynamic_entry (DT_RELAENT
, sizeof (ElfNN_External_Rela
)))
1367 /* If any dynamic relocs apply to a read-only section,
1368 then we need a DT_TEXTREL entry. */
1369 if ((info
->flags
& DF_TEXTREL
) == 0)
1370 elf_link_hash_traverse (&htab
->elf
, maybe_set_textrel
, info
);
1372 if (info
->flags
& DF_TEXTREL
)
1374 if (!add_dynamic_entry (DT_TEXTREL
, 0))
1378 #undef add_dynamic_entry
1384 #define DTP_OFFSET 0x800
1386 /* Return the relocation value for a TLS dtp-relative reloc. */
1389 dtpoff (struct bfd_link_info
*info
, bfd_vma address
)
1391 /* If tls_sec is NULL, we should have signalled an error already. */
1392 if (elf_hash_table (info
)->tls_sec
== NULL
)
1394 return address
- elf_hash_table (info
)->tls_sec
->vma
- DTP_OFFSET
;
1397 /* Return the relocation value for a static TLS tp-relative relocation. */
1400 tpoff (struct bfd_link_info
*info
, bfd_vma address
)
1402 /* If tls_sec is NULL, we should have signalled an error already. */
1403 if (elf_hash_table (info
)->tls_sec
== NULL
)
1405 return address
- elf_hash_table (info
)->tls_sec
->vma
- TP_OFFSET
;
1408 /* Return the global pointer's value, or 0 if it is not in use. */
1411 riscv_global_pointer_value (struct bfd_link_info
*info
)
1413 struct bfd_link_hash_entry
*h
;
1415 h
= bfd_link_hash_lookup (info
->hash
, RISCV_GP_SYMBOL
, FALSE
, FALSE
, TRUE
);
1416 if (h
== NULL
|| h
->type
!= bfd_link_hash_defined
)
1419 return h
->u
.def
.value
+ sec_addr (h
->u
.def
.section
);
1422 /* Emplace a static relocation. */
1424 static bfd_reloc_status_type
1425 perform_relocation (const reloc_howto_type
*howto
,
1426 const Elf_Internal_Rela
*rel
,
1428 asection
*input_section
,
1432 if (howto
->pc_relative
)
1433 value
-= sec_addr (input_section
) + rel
->r_offset
;
1434 value
+= rel
->r_addend
;
1436 switch (ELFNN_R_TYPE (rel
->r_info
))
1439 case R_RISCV_TPREL_HI20
:
1440 case R_RISCV_PCREL_HI20
:
1441 case R_RISCV_GOT_HI20
:
1442 case R_RISCV_TLS_GOT_HI20
:
1443 case R_RISCV_TLS_GD_HI20
:
1444 if (ARCH_SIZE
> 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (value
)))
1445 return bfd_reloc_overflow
;
1446 value
= ENCODE_UTYPE_IMM (RISCV_CONST_HIGH_PART (value
));
1449 case R_RISCV_LO12_I
:
1450 case R_RISCV_GPREL_I
:
1451 case R_RISCV_TPREL_LO12_I
:
1452 case R_RISCV_TPREL_I
:
1453 case R_RISCV_PCREL_LO12_I
:
1454 value
= ENCODE_ITYPE_IMM (value
);
1457 case R_RISCV_LO12_S
:
1458 case R_RISCV_GPREL_S
:
1459 case R_RISCV_TPREL_LO12_S
:
1460 case R_RISCV_TPREL_S
:
1461 case R_RISCV_PCREL_LO12_S
:
1462 value
= ENCODE_STYPE_IMM (value
);
1466 case R_RISCV_CALL_PLT
:
1467 if (ARCH_SIZE
> 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (value
)))
1468 return bfd_reloc_overflow
;
1469 value
= ENCODE_UTYPE_IMM (RISCV_CONST_HIGH_PART (value
))
1470 | (ENCODE_ITYPE_IMM (value
) << 32);
1474 if (!VALID_UJTYPE_IMM (value
))
1475 return bfd_reloc_overflow
;
1476 value
= ENCODE_UJTYPE_IMM (value
);
1479 case R_RISCV_BRANCH
:
1480 if (!VALID_SBTYPE_IMM (value
))
1481 return bfd_reloc_overflow
;
1482 value
= ENCODE_SBTYPE_IMM (value
);
1485 case R_RISCV_RVC_BRANCH
:
1486 if (!VALID_RVC_B_IMM (value
))
1487 return bfd_reloc_overflow
;
1488 value
= ENCODE_RVC_B_IMM (value
);
1491 case R_RISCV_RVC_JUMP
:
1492 if (!VALID_RVC_J_IMM (value
))
1493 return bfd_reloc_overflow
;
1494 value
= ENCODE_RVC_J_IMM (value
);
1497 case R_RISCV_RVC_LUI
:
1498 if (RISCV_CONST_HIGH_PART (value
) == 0)
1500 /* Linker relaxation can convert an address equal to or greater than
1501 0x800 to slightly below 0x800. C.LUI does not accept zero as a
1502 valid immediate. We can fix this by converting it to a C.LI. */
1503 bfd_vma insn
= bfd_get (howto
->bitsize
, input_bfd
,
1504 contents
+ rel
->r_offset
);
1505 insn
= (insn
& ~MATCH_C_LUI
) | MATCH_C_LI
;
1506 bfd_put (howto
->bitsize
, input_bfd
, insn
, contents
+ rel
->r_offset
);
1507 value
= ENCODE_RVC_IMM (0);
1509 else if (!VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (value
)))
1510 return bfd_reloc_overflow
;
1512 value
= ENCODE_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (value
));
1530 case R_RISCV_32_PCREL
:
1531 case R_RISCV_TLS_DTPREL32
:
1532 case R_RISCV_TLS_DTPREL64
:
1535 case R_RISCV_DELETE
:
1536 return bfd_reloc_ok
;
1539 return bfd_reloc_notsupported
;
1542 bfd_vma word
= bfd_get (howto
->bitsize
, input_bfd
, contents
+ rel
->r_offset
);
1543 word
= (word
& ~howto
->dst_mask
) | (value
& howto
->dst_mask
);
1544 bfd_put (howto
->bitsize
, input_bfd
, word
, contents
+ rel
->r_offset
);
1546 return bfd_reloc_ok
;
1549 /* Remember all PC-relative high-part relocs we've encountered to help us
1550 later resolve the corresponding low-part relocs. */
1556 } riscv_pcrel_hi_reloc
;
1558 typedef struct riscv_pcrel_lo_reloc
1560 asection
* input_section
;
1561 struct bfd_link_info
* info
;
1562 reloc_howto_type
* howto
;
1563 const Elf_Internal_Rela
* reloc
;
1566 bfd_byte
* contents
;
1567 struct riscv_pcrel_lo_reloc
* next
;
1568 } riscv_pcrel_lo_reloc
;
1573 riscv_pcrel_lo_reloc
*lo_relocs
;
1574 } riscv_pcrel_relocs
;
1577 riscv_pcrel_reloc_hash (const void *entry
)
1579 const riscv_pcrel_hi_reloc
*e
= entry
;
1580 return (hashval_t
)(e
->address
>> 2);
1584 riscv_pcrel_reloc_eq (const void *entry1
, const void *entry2
)
1586 const riscv_pcrel_hi_reloc
*e1
= entry1
, *e2
= entry2
;
1587 return e1
->address
== e2
->address
;
1591 riscv_init_pcrel_relocs (riscv_pcrel_relocs
*p
)
1594 p
->lo_relocs
= NULL
;
1595 p
->hi_relocs
= htab_create (1024, riscv_pcrel_reloc_hash
,
1596 riscv_pcrel_reloc_eq
, free
);
1597 return p
->hi_relocs
!= NULL
;
1601 riscv_free_pcrel_relocs (riscv_pcrel_relocs
*p
)
1603 riscv_pcrel_lo_reloc
*cur
= p
->lo_relocs
;
1607 riscv_pcrel_lo_reloc
*next
= cur
->next
;
1612 htab_delete (p
->hi_relocs
);
1616 riscv_zero_pcrel_hi_reloc (Elf_Internal_Rela
*rel
,
1617 struct bfd_link_info
*info
,
1621 const reloc_howto_type
*howto
,
1624 /* We may need to reference low addreses in PC-relative modes even when the
1625 * PC is far away from these addresses. For example, undefweak references
1626 * need to produce the address 0 when linked. As 0 is far from the arbitrary
1627 * addresses that we can link PC-relative programs at, the linker can't
1628 * actually relocate references to those symbols. In order to allow these
1629 * programs to work we simply convert the PC-relative auipc sequences to
1630 * 0-relative lui sequences. */
1631 if (bfd_link_pic (info
))
1634 /* If it's possible to reference the symbol using auipc we do so, as that's
1635 * more in the spirit of the PC-relative relocations we're processing. */
1636 bfd_vma offset
= addr
- pc
;
1637 if (ARCH_SIZE
== 32 || VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (offset
)))
1640 /* If it's impossible to reference this with a LUI-based offset then don't
1641 * bother to convert it at all so users still see the PC-relative relocation
1642 * in the truncation message. */
1643 if (ARCH_SIZE
> 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (addr
)))
1646 rel
->r_info
= ELFNN_R_INFO(addr
, R_RISCV_HI20
);
1648 bfd_vma insn
= bfd_get(howto
->bitsize
, input_bfd
, contents
+ rel
->r_offset
);
1649 insn
= (insn
& ~MASK_AUIPC
) | MATCH_LUI
;
1650 bfd_put(howto
->bitsize
, input_bfd
, insn
, contents
+ rel
->r_offset
);
1655 riscv_record_pcrel_hi_reloc (riscv_pcrel_relocs
*p
, bfd_vma addr
,
1656 bfd_vma value
, bfd_boolean absolute
)
1658 bfd_vma offset
= absolute
? value
: value
- addr
;
1659 riscv_pcrel_hi_reloc entry
= {addr
, offset
};
1660 riscv_pcrel_hi_reloc
**slot
=
1661 (riscv_pcrel_hi_reloc
**) htab_find_slot (p
->hi_relocs
, &entry
, INSERT
);
1663 BFD_ASSERT (*slot
== NULL
);
1664 *slot
= (riscv_pcrel_hi_reloc
*) bfd_malloc (sizeof (riscv_pcrel_hi_reloc
));
1672 riscv_record_pcrel_lo_reloc (riscv_pcrel_relocs
*p
,
1673 asection
*input_section
,
1674 struct bfd_link_info
*info
,
1675 reloc_howto_type
*howto
,
1676 const Elf_Internal_Rela
*reloc
,
1681 riscv_pcrel_lo_reloc
*entry
;
1682 entry
= (riscv_pcrel_lo_reloc
*) bfd_malloc (sizeof (riscv_pcrel_lo_reloc
));
1685 *entry
= (riscv_pcrel_lo_reloc
) {input_section
, info
, howto
, reloc
, addr
,
1686 name
, contents
, p
->lo_relocs
};
1687 p
->lo_relocs
= entry
;
1692 riscv_resolve_pcrel_lo_relocs (riscv_pcrel_relocs
*p
)
1694 riscv_pcrel_lo_reloc
*r
;
1696 for (r
= p
->lo_relocs
; r
!= NULL
; r
= r
->next
)
1698 bfd
*input_bfd
= r
->input_section
->owner
;
1700 riscv_pcrel_hi_reloc search
= {r
->addr
, 0};
1701 riscv_pcrel_hi_reloc
*entry
= htab_find (p
->hi_relocs
, &search
);
1703 /* Check for overflow into bit 11 when adding reloc addend. */
1704 || (! (entry
->value
& 0x800)
1705 && ((entry
->value
+ r
->reloc
->r_addend
) & 0x800)))
1707 char *string
= (entry
== NULL
1708 ? "%pcrel_lo missing matching %pcrel_hi"
1709 : "%pcrel_lo overflow with an addend");
1710 (*r
->info
->callbacks
->reloc_dangerous
)
1711 (r
->info
, string
, input_bfd
, r
->input_section
, r
->reloc
->r_offset
);
1715 perform_relocation (r
->howto
, r
->reloc
, entry
->value
, r
->input_section
,
1716 input_bfd
, r
->contents
);
1722 /* Relocate a RISC-V ELF section.
1724 The RELOCATE_SECTION function is called by the new ELF backend linker
1725 to handle the relocations for a section.
1727 The relocs are always passed as Rela structures.
1729 This function is responsible for adjusting the section contents as
1730 necessary, and (if generating a relocatable output file) adjusting
1731 the reloc addend as necessary.
1733 This function does not have to worry about setting the reloc
1734 address or the reloc symbol index.
1736 LOCAL_SYMS is a pointer to the swapped in local symbols.
1738 LOCAL_SECTIONS is an array giving the section in the input file
1739 corresponding to the st_shndx field of each local symbol.
1741 The global hash table entry for the global symbols can be found
1742 via elf_sym_hashes (input_bfd).
1744 When generating relocatable output, this function must handle
1745 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
1746 going to be the section symbol corresponding to the output
1747 section, which means that the addend must be adjusted
1751 riscv_elf_relocate_section (bfd
*output_bfd
,
1752 struct bfd_link_info
*info
,
1754 asection
*input_section
,
1756 Elf_Internal_Rela
*relocs
,
1757 Elf_Internal_Sym
*local_syms
,
1758 asection
**local_sections
)
1760 Elf_Internal_Rela
*rel
;
1761 Elf_Internal_Rela
*relend
;
1762 riscv_pcrel_relocs pcrel_relocs
;
1763 bfd_boolean ret
= FALSE
;
1764 asection
*sreloc
= elf_section_data (input_section
)->sreloc
;
1765 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
1766 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (input_bfd
);
1767 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (input_bfd
);
1768 bfd_vma
*local_got_offsets
= elf_local_got_offsets (input_bfd
);
1769 bfd_boolean absolute
;
1771 if (!riscv_init_pcrel_relocs (&pcrel_relocs
))
1774 relend
= relocs
+ input_section
->reloc_count
;
1775 for (rel
= relocs
; rel
< relend
; rel
++)
1777 unsigned long r_symndx
;
1778 struct elf_link_hash_entry
*h
;
1779 Elf_Internal_Sym
*sym
;
1782 bfd_reloc_status_type r
= bfd_reloc_ok
;
1784 bfd_vma off
, ie_off
;
1785 bfd_boolean unresolved_reloc
, is_ie
= FALSE
;
1786 bfd_vma pc
= sec_addr (input_section
) + rel
->r_offset
;
1787 int r_type
= ELFNN_R_TYPE (rel
->r_info
), tls_type
;
1788 reloc_howto_type
*howto
= riscv_elf_rtype_to_howto (input_bfd
, r_type
);
1789 const char *msg
= NULL
;
1790 char *msg_buf
= NULL
;
1791 bfd_boolean resolved_to_zero
;
1794 || r_type
== R_RISCV_GNU_VTINHERIT
|| r_type
== R_RISCV_GNU_VTENTRY
)
1797 /* This is a final link. */
1798 r_symndx
= ELFNN_R_SYM (rel
->r_info
);
1802 unresolved_reloc
= FALSE
;
1803 if (r_symndx
< symtab_hdr
->sh_info
)
1805 sym
= local_syms
+ r_symndx
;
1806 sec
= local_sections
[r_symndx
];
1807 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
1811 bfd_boolean warned
, ignored
;
1813 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
1814 r_symndx
, symtab_hdr
, sym_hashes
,
1816 unresolved_reloc
, warned
, ignored
);
1819 /* To avoid generating warning messages about truncated
1820 relocations, set the relocation's address to be the same as
1821 the start of this section. */
1822 if (input_section
->output_section
!= NULL
)
1823 relocation
= input_section
->output_section
->vma
;
1829 if (sec
!= NULL
&& discarded_section (sec
))
1830 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
1831 rel
, 1, relend
, howto
, 0, contents
);
1833 if (bfd_link_relocatable (info
))
1837 name
= h
->root
.root
.string
;
1840 name
= (bfd_elf_string_from_elf_section
1841 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
1842 if (name
== NULL
|| *name
== '\0')
1843 name
= bfd_section_name (sec
);
1846 resolved_to_zero
= (h
!= NULL
1847 && UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
));
1853 case R_RISCV_TPREL_ADD
:
1855 case R_RISCV_JUMP_SLOT
:
1856 case R_RISCV_RELATIVE
:
1857 /* These require nothing of us at all. */
1861 case R_RISCV_BRANCH
:
1862 case R_RISCV_RVC_BRANCH
:
1863 case R_RISCV_RVC_LUI
:
1864 case R_RISCV_LO12_I
:
1865 case R_RISCV_LO12_S
:
1870 case R_RISCV_32_PCREL
:
1871 case R_RISCV_DELETE
:
1872 /* These require no special handling beyond perform_relocation. */
1875 case R_RISCV_GOT_HI20
:
1878 bfd_boolean dyn
, pic
;
1880 off
= h
->got
.offset
;
1881 BFD_ASSERT (off
!= (bfd_vma
) -1);
1882 dyn
= elf_hash_table (info
)->dynamic_sections_created
;
1883 pic
= bfd_link_pic (info
);
1885 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, pic
, h
)
1886 || (pic
&& SYMBOL_REFERENCES_LOCAL (info
, h
)))
1888 /* This is actually a static link, or it is a
1889 -Bsymbolic link and the symbol is defined
1890 locally, or the symbol was forced to be local
1891 because of a version file. We must initialize
1892 this entry in the global offset table. Since the
1893 offset must always be a multiple of the word size,
1894 we use the least significant bit to record whether
1895 we have initialized it already.
1897 When doing a dynamic link, we create a .rela.got
1898 relocation entry to initialize the value. This
1899 is done in the finish_dynamic_symbol routine. */
1904 bfd_put_NN (output_bfd
, relocation
,
1905 htab
->elf
.sgot
->contents
+ off
);
1910 unresolved_reloc
= FALSE
;
1914 BFD_ASSERT (local_got_offsets
!= NULL
1915 && local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
1917 off
= local_got_offsets
[r_symndx
];
1919 /* The offset must always be a multiple of the word size.
1920 So, we can use the least significant bit to record
1921 whether we have already processed this entry. */
1926 if (bfd_link_pic (info
))
1929 Elf_Internal_Rela outrel
;
1931 /* We need to generate a R_RISCV_RELATIVE reloc
1932 for the dynamic linker. */
1933 s
= htab
->elf
.srelgot
;
1934 BFD_ASSERT (s
!= NULL
);
1936 outrel
.r_offset
= sec_addr (htab
->elf
.sgot
) + off
;
1938 ELFNN_R_INFO (0, R_RISCV_RELATIVE
);
1939 outrel
.r_addend
= relocation
;
1941 riscv_elf_append_rela (output_bfd
, s
, &outrel
);
1944 bfd_put_NN (output_bfd
, relocation
,
1945 htab
->elf
.sgot
->contents
+ off
);
1946 local_got_offsets
[r_symndx
] |= 1;
1949 relocation
= sec_addr (htab
->elf
.sgot
) + off
;
1950 absolute
= riscv_zero_pcrel_hi_reloc (rel
,
1957 r_type
= ELFNN_R_TYPE (rel
->r_info
);
1958 howto
= riscv_elf_rtype_to_howto (input_bfd
, r_type
);
1960 r
= bfd_reloc_notsupported
;
1961 else if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs
, pc
,
1962 relocation
, absolute
))
1963 r
= bfd_reloc_overflow
;
1971 bfd_vma old_value
= bfd_get (howto
->bitsize
, input_bfd
,
1972 contents
+ rel
->r_offset
);
1973 relocation
= old_value
+ relocation
;
1983 bfd_vma old_value
= bfd_get (howto
->bitsize
, input_bfd
,
1984 contents
+ rel
->r_offset
);
1985 relocation
= old_value
- relocation
;
1990 case R_RISCV_CALL_PLT
:
1991 /* Handle a call to an undefined weak function. This won't be
1992 relaxed, so we have to handle it here. */
1993 if (h
!= NULL
&& h
->root
.type
== bfd_link_hash_undefweak
1994 && (!bfd_link_pic (info
) || h
->plt
.offset
== MINUS_ONE
))
1996 /* We can use x0 as the base register. */
1997 bfd_vma insn
= bfd_get_32 (input_bfd
,
1998 contents
+ rel
->r_offset
+ 4);
1999 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
2000 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
+ 4);
2001 /* Set the relocation value so that we get 0 after the pc
2002 relative adjustment. */
2003 relocation
= sec_addr (input_section
) + rel
->r_offset
;
2008 case R_RISCV_RVC_JUMP
:
2009 /* This line has to match the check in _bfd_riscv_relax_section. */
2010 if (bfd_link_pic (info
) && h
!= NULL
&& h
->plt
.offset
!= MINUS_ONE
)
2012 /* Refer to the PLT entry. */
2013 relocation
= sec_addr (htab
->elf
.splt
) + h
->plt
.offset
;
2014 unresolved_reloc
= FALSE
;
2018 case R_RISCV_TPREL_HI20
:
2019 relocation
= tpoff (info
, relocation
);
2022 case R_RISCV_TPREL_LO12_I
:
2023 case R_RISCV_TPREL_LO12_S
:
2024 relocation
= tpoff (info
, relocation
);
2027 case R_RISCV_TPREL_I
:
2028 case R_RISCV_TPREL_S
:
2029 relocation
= tpoff (info
, relocation
);
2030 if (VALID_ITYPE_IMM (relocation
+ rel
->r_addend
))
2032 /* We can use tp as the base register. */
2033 bfd_vma insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2034 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
2035 insn
|= X_TP
<< OP_SH_RS1
;
2036 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
2039 r
= bfd_reloc_overflow
;
2042 case R_RISCV_GPREL_I
:
2043 case R_RISCV_GPREL_S
:
2045 bfd_vma gp
= riscv_global_pointer_value (info
);
2046 bfd_boolean x0_base
= VALID_ITYPE_IMM (relocation
+ rel
->r_addend
);
2047 if (x0_base
|| VALID_ITYPE_IMM (relocation
+ rel
->r_addend
- gp
))
2049 /* We can use x0 or gp as the base register. */
2050 bfd_vma insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2051 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
2054 rel
->r_addend
-= gp
;
2055 insn
|= X_GP
<< OP_SH_RS1
;
2057 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
2060 r
= bfd_reloc_overflow
;
2064 case R_RISCV_PCREL_HI20
:
2065 absolute
= riscv_zero_pcrel_hi_reloc (rel
,
2072 r_type
= ELFNN_R_TYPE (rel
->r_info
);
2073 howto
= riscv_elf_rtype_to_howto (input_bfd
, r_type
);
2075 r
= bfd_reloc_notsupported
;
2076 else if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs
, pc
,
2077 relocation
+ rel
->r_addend
,
2079 r
= bfd_reloc_overflow
;
2082 case R_RISCV_PCREL_LO12_I
:
2083 case R_RISCV_PCREL_LO12_S
:
2084 /* We don't allow section symbols plus addends as the auipc address,
2085 because then riscv_relax_delete_bytes would have to search through
2086 all relocs to update these addends. This is also ambiguous, as
2087 we do allow offsets to be added to the target address, which are
2088 not to be used to find the auipc address. */
2089 if (((sym
!= NULL
&& (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
))
2090 || (h
!= NULL
&& h
->type
== STT_SECTION
))
2093 msg
= _("%pcrel_lo section symbol with an addend");
2094 r
= bfd_reloc_dangerous
;
2098 if (riscv_record_pcrel_lo_reloc (&pcrel_relocs
, input_section
, info
,
2099 howto
, rel
, relocation
, name
,
2102 r
= bfd_reloc_overflow
;
2105 case R_RISCV_TLS_DTPREL32
:
2106 case R_RISCV_TLS_DTPREL64
:
2107 relocation
= dtpoff (info
, relocation
);
2112 if ((input_section
->flags
& SEC_ALLOC
) == 0)
2115 if ((bfd_link_pic (info
)
2117 || (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2118 && !resolved_to_zero
)
2119 || h
->root
.type
!= bfd_link_hash_undefweak
)
2120 && (! howto
->pc_relative
2121 || !SYMBOL_CALLS_LOCAL (info
, h
)))
2122 || (!bfd_link_pic (info
)
2128 || h
->root
.type
== bfd_link_hash_undefweak
2129 || h
->root
.type
== bfd_link_hash_undefined
)))
2131 Elf_Internal_Rela outrel
;
2132 bfd_boolean skip_static_relocation
, skip_dynamic_relocation
;
2134 /* When generating a shared object, these relocations
2135 are copied into the output file to be resolved at run
2139 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
2141 skip_static_relocation
= outrel
.r_offset
!= (bfd_vma
) -2;
2142 skip_dynamic_relocation
= outrel
.r_offset
>= (bfd_vma
) -2;
2143 outrel
.r_offset
+= sec_addr (input_section
);
2145 if (skip_dynamic_relocation
)
2146 memset (&outrel
, 0, sizeof outrel
);
2147 else if (h
!= NULL
&& h
->dynindx
!= -1
2148 && !(bfd_link_pic (info
)
2149 && SYMBOLIC_BIND (info
, h
)
2152 outrel
.r_info
= ELFNN_R_INFO (h
->dynindx
, r_type
);
2153 outrel
.r_addend
= rel
->r_addend
;
2157 outrel
.r_info
= ELFNN_R_INFO (0, R_RISCV_RELATIVE
);
2158 outrel
.r_addend
= relocation
+ rel
->r_addend
;
2161 riscv_elf_append_rela (output_bfd
, sreloc
, &outrel
);
2162 if (skip_static_relocation
)
2167 case R_RISCV_TLS_GOT_HI20
:
2171 case R_RISCV_TLS_GD_HI20
:
2174 off
= h
->got
.offset
;
2179 off
= local_got_offsets
[r_symndx
];
2180 local_got_offsets
[r_symndx
] |= 1;
2183 tls_type
= _bfd_riscv_elf_tls_type (input_bfd
, h
, r_symndx
);
2184 BFD_ASSERT (tls_type
& (GOT_TLS_IE
| GOT_TLS_GD
));
2185 /* If this symbol is referenced by both GD and IE TLS, the IE
2186 reference's GOT slot follows the GD reference's slots. */
2188 if ((tls_type
& GOT_TLS_GD
) && (tls_type
& GOT_TLS_IE
))
2189 ie_off
= 2 * GOT_ENTRY_SIZE
;
2195 Elf_Internal_Rela outrel
;
2197 bfd_boolean need_relocs
= FALSE
;
2199 if (htab
->elf
.srelgot
== NULL
)
2204 bfd_boolean dyn
, pic
;
2205 dyn
= htab
->elf
.dynamic_sections_created
;
2206 pic
= bfd_link_pic (info
);
2208 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, pic
, h
)
2209 && (!pic
|| !SYMBOL_REFERENCES_LOCAL (info
, h
)))
2213 /* The GOT entries have not been initialized yet. Do it
2214 now, and emit any relocations. */
2215 if ((bfd_link_pic (info
) || indx
!= 0)
2217 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2218 || h
->root
.type
!= bfd_link_hash_undefweak
))
2221 if (tls_type
& GOT_TLS_GD
)
2225 outrel
.r_offset
= sec_addr (htab
->elf
.sgot
) + off
;
2226 outrel
.r_addend
= 0;
2227 outrel
.r_info
= ELFNN_R_INFO (indx
, R_RISCV_TLS_DTPMODNN
);
2228 bfd_put_NN (output_bfd
, 0,
2229 htab
->elf
.sgot
->contents
+ off
);
2230 riscv_elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &outrel
);
2233 BFD_ASSERT (! unresolved_reloc
);
2234 bfd_put_NN (output_bfd
,
2235 dtpoff (info
, relocation
),
2236 (htab
->elf
.sgot
->contents
+ off
+
2237 RISCV_ELF_WORD_BYTES
));
2241 bfd_put_NN (output_bfd
, 0,
2242 (htab
->elf
.sgot
->contents
+ off
+
2243 RISCV_ELF_WORD_BYTES
));
2244 outrel
.r_info
= ELFNN_R_INFO (indx
, R_RISCV_TLS_DTPRELNN
);
2245 outrel
.r_offset
+= RISCV_ELF_WORD_BYTES
;
2246 riscv_elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &outrel
);
2251 /* If we are not emitting relocations for a
2252 general dynamic reference, then we must be in a
2253 static link or an executable link with the
2254 symbol binding locally. Mark it as belonging
2255 to module 1, the executable. */
2256 bfd_put_NN (output_bfd
, 1,
2257 htab
->elf
.sgot
->contents
+ off
);
2258 bfd_put_NN (output_bfd
,
2259 dtpoff (info
, relocation
),
2260 (htab
->elf
.sgot
->contents
+ off
+
2261 RISCV_ELF_WORD_BYTES
));
2265 if (tls_type
& GOT_TLS_IE
)
2269 bfd_put_NN (output_bfd
, 0,
2270 htab
->elf
.sgot
->contents
+ off
+ ie_off
);
2271 outrel
.r_offset
= sec_addr (htab
->elf
.sgot
)
2273 outrel
.r_addend
= 0;
2275 outrel
.r_addend
= tpoff (info
, relocation
);
2276 outrel
.r_info
= ELFNN_R_INFO (indx
, R_RISCV_TLS_TPRELNN
);
2277 riscv_elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &outrel
);
2281 bfd_put_NN (output_bfd
, tpoff (info
, relocation
),
2282 htab
->elf
.sgot
->contents
+ off
+ ie_off
);
2287 BFD_ASSERT (off
< (bfd_vma
) -2);
2288 relocation
= sec_addr (htab
->elf
.sgot
) + off
+ (is_ie
? ie_off
: 0);
2289 if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs
, pc
,
2291 r
= bfd_reloc_overflow
;
2292 unresolved_reloc
= FALSE
;
2296 r
= bfd_reloc_notsupported
;
2299 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2300 because such sections are not SEC_ALLOC and thus ld.so will
2301 not process them. */
2302 if (unresolved_reloc
2303 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
2305 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
2306 rel
->r_offset
) != (bfd_vma
) -1)
2312 case R_RISCV_RVC_JUMP
:
2313 if (asprintf (&msg_buf
,
2314 _("%%X%%P: relocation %s against `%s' can "
2315 "not be used when making a shared object; "
2316 "recompile with -fPIC\n"),
2318 h
->root
.root
.string
) == -1)
2323 if (asprintf (&msg_buf
,
2324 _("%%X%%P: unresolvable %s relocation against "
2327 h
->root
.root
.string
) == -1)
2333 r
= bfd_reloc_notsupported
;
2336 if (r
== bfd_reloc_ok
)
2337 r
= perform_relocation (howto
, rel
, relocation
, input_section
,
2338 input_bfd
, contents
);
2340 /* We should have already detected the error and set message before.
2341 If the error message isn't set since the linker runs out of memory
2342 or we don't set it before, then we should set the default message
2343 with the "internal error" string here. */
2349 case bfd_reloc_overflow
:
2350 info
->callbacks
->reloc_overflow
2351 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
2352 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
2355 case bfd_reloc_undefined
:
2356 info
->callbacks
->undefined_symbol
2357 (info
, name
, input_bfd
, input_section
, rel
->r_offset
,
2361 case bfd_reloc_outofrange
:
2363 msg
= _("%X%P: internal error: out of range error\n");
2366 case bfd_reloc_notsupported
:
2368 msg
= _("%X%P: internal error: unsupported relocation error\n");
2371 case bfd_reloc_dangerous
:
2372 /* The error message should already be set. */
2374 msg
= _("dangerous relocation error");
2375 info
->callbacks
->reloc_dangerous
2376 (info
, msg
, input_bfd
, input_section
, rel
->r_offset
);
2380 msg
= _("%X%P: internal error: unknown error\n");
2384 /* Do not report error message for the dangerous relocation again. */
2385 if (msg
&& r
!= bfd_reloc_dangerous
)
2386 info
->callbacks
->einfo (msg
);
2388 /* Free the unused `msg_buf` if needed. */
2392 /* We already reported the error via a callback, so don't try to report
2393 it again by returning false. That leads to spurious errors. */
2398 ret
= riscv_resolve_pcrel_lo_relocs (&pcrel_relocs
);
2400 riscv_free_pcrel_relocs (&pcrel_relocs
);
2404 /* Finish up dynamic symbol handling. We set the contents of various
2405 dynamic sections here. */
2408 riscv_elf_finish_dynamic_symbol (bfd
*output_bfd
,
2409 struct bfd_link_info
*info
,
2410 struct elf_link_hash_entry
*h
,
2411 Elf_Internal_Sym
*sym
)
2413 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
2414 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
2416 if (h
->plt
.offset
!= (bfd_vma
) -1)
2418 /* We've decided to create a PLT entry for this symbol. */
2420 bfd_vma i
, header_address
, plt_idx
, got_address
;
2421 uint32_t plt_entry
[PLT_ENTRY_INSNS
];
2422 Elf_Internal_Rela rela
;
2424 BFD_ASSERT (h
->dynindx
!= -1);
2426 /* Calculate the address of the PLT header. */
2427 header_address
= sec_addr (htab
->elf
.splt
);
2429 /* Calculate the index of the entry. */
2430 plt_idx
= (h
->plt
.offset
- PLT_HEADER_SIZE
) / PLT_ENTRY_SIZE
;
2432 /* Calculate the address of the .got.plt entry. */
2433 got_address
= riscv_elf_got_plt_val (plt_idx
, info
);
2435 /* Find out where the .plt entry should go. */
2436 loc
= htab
->elf
.splt
->contents
+ h
->plt
.offset
;
2438 /* Fill in the PLT entry itself. */
2439 if (! riscv_make_plt_entry (output_bfd
, got_address
,
2440 header_address
+ h
->plt
.offset
,
2444 for (i
= 0; i
< PLT_ENTRY_INSNS
; i
++)
2445 bfd_put_32 (output_bfd
, plt_entry
[i
], loc
+ 4*i
);
2447 /* Fill in the initial value of the .got.plt entry. */
2448 loc
= htab
->elf
.sgotplt
->contents
2449 + (got_address
- sec_addr (htab
->elf
.sgotplt
));
2450 bfd_put_NN (output_bfd
, sec_addr (htab
->elf
.splt
), loc
);
2452 /* Fill in the entry in the .rela.plt section. */
2453 rela
.r_offset
= got_address
;
2455 rela
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_RISCV_JUMP_SLOT
);
2457 loc
= htab
->elf
.srelplt
->contents
+ plt_idx
* sizeof (ElfNN_External_Rela
);
2458 bed
->s
->swap_reloca_out (output_bfd
, &rela
, loc
);
2460 if (!h
->def_regular
)
2462 /* Mark the symbol as undefined, rather than as defined in
2463 the .plt section. Leave the value alone. */
2464 sym
->st_shndx
= SHN_UNDEF
;
2465 /* If the symbol is weak, we do need to clear the value.
2466 Otherwise, the PLT entry would provide a definition for
2467 the symbol even if the symbol wasn't defined anywhere,
2468 and so the symbol would never be NULL. */
2469 if (!h
->ref_regular_nonweak
)
2474 if (h
->got
.offset
!= (bfd_vma
) -1
2475 && !(riscv_elf_hash_entry (h
)->tls_type
& (GOT_TLS_GD
| GOT_TLS_IE
))
2476 && !UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
2480 Elf_Internal_Rela rela
;
2482 /* This symbol has an entry in the GOT. Set it up. */
2484 sgot
= htab
->elf
.sgot
;
2485 srela
= htab
->elf
.srelgot
;
2486 BFD_ASSERT (sgot
!= NULL
&& srela
!= NULL
);
2488 rela
.r_offset
= sec_addr (sgot
) + (h
->got
.offset
&~ (bfd_vma
) 1);
2490 /* If this is a local symbol reference, we just want to emit a RELATIVE
2491 reloc. This can happen if it is a -Bsymbolic link, or a pie link, or
2492 the symbol was forced to be local because of a version file.
2493 The entry in the global offset table will already have been
2494 initialized in the relocate_section function. */
2495 if (bfd_link_pic (info
)
2496 && SYMBOL_REFERENCES_LOCAL (info
, h
))
2498 BFD_ASSERT((h
->got
.offset
& 1) != 0);
2499 asection
*sec
= h
->root
.u
.def
.section
;
2500 rela
.r_info
= ELFNN_R_INFO (0, R_RISCV_RELATIVE
);
2501 rela
.r_addend
= (h
->root
.u
.def
.value
2502 + sec
->output_section
->vma
2503 + sec
->output_offset
);
2507 BFD_ASSERT((h
->got
.offset
& 1) == 0);
2508 BFD_ASSERT (h
->dynindx
!= -1);
2509 rela
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_RISCV_NN
);
2513 bfd_put_NN (output_bfd
, 0,
2514 sgot
->contents
+ (h
->got
.offset
& ~(bfd_vma
) 1));
2515 riscv_elf_append_rela (output_bfd
, srela
, &rela
);
2520 Elf_Internal_Rela rela
;
2523 /* This symbols needs a copy reloc. Set it up. */
2524 BFD_ASSERT (h
->dynindx
!= -1);
2526 rela
.r_offset
= sec_addr (h
->root
.u
.def
.section
) + h
->root
.u
.def
.value
;
2527 rela
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_RISCV_COPY
);
2529 if (h
->root
.u
.def
.section
== htab
->elf
.sdynrelro
)
2530 s
= htab
->elf
.sreldynrelro
;
2532 s
= htab
->elf
.srelbss
;
2533 riscv_elf_append_rela (output_bfd
, s
, &rela
);
2536 /* Mark some specially defined symbols as absolute. */
2537 if (h
== htab
->elf
.hdynamic
2538 || (h
== htab
->elf
.hgot
|| h
== htab
->elf
.hplt
))
2539 sym
->st_shndx
= SHN_ABS
;
2544 /* Finish up the dynamic sections. */
2547 riscv_finish_dyn (bfd
*output_bfd
, struct bfd_link_info
*info
,
2548 bfd
*dynobj
, asection
*sdyn
)
2550 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
2551 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
2552 size_t dynsize
= bed
->s
->sizeof_dyn
;
2553 bfd_byte
*dyncon
, *dynconend
;
2555 dynconend
= sdyn
->contents
+ sdyn
->size
;
2556 for (dyncon
= sdyn
->contents
; dyncon
< dynconend
; dyncon
+= dynsize
)
2558 Elf_Internal_Dyn dyn
;
2561 bed
->s
->swap_dyn_in (dynobj
, dyncon
, &dyn
);
2566 s
= htab
->elf
.sgotplt
;
2567 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
2570 s
= htab
->elf
.srelplt
;
2571 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
2574 s
= htab
->elf
.srelplt
;
2575 dyn
.d_un
.d_val
= s
->size
;
2581 bed
->s
->swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2587 riscv_elf_finish_dynamic_sections (bfd
*output_bfd
,
2588 struct bfd_link_info
*info
)
2592 struct riscv_elf_link_hash_table
*htab
;
2594 htab
= riscv_elf_hash_table (info
);
2595 BFD_ASSERT (htab
!= NULL
);
2596 dynobj
= htab
->elf
.dynobj
;
2598 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
2600 if (elf_hash_table (info
)->dynamic_sections_created
)
2605 splt
= htab
->elf
.splt
;
2606 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
2608 ret
= riscv_finish_dyn (output_bfd
, info
, dynobj
, sdyn
);
2613 /* Fill in the head and tail entries in the procedure linkage table. */
2617 uint32_t plt_header
[PLT_HEADER_INSNS
];
2618 ret
= riscv_make_plt_header (output_bfd
,
2619 sec_addr (htab
->elf
.sgotplt
),
2620 sec_addr (splt
), plt_header
);
2624 for (i
= 0; i
< PLT_HEADER_INSNS
; i
++)
2625 bfd_put_32 (output_bfd
, plt_header
[i
], splt
->contents
+ 4*i
);
2627 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
2632 if (htab
->elf
.sgotplt
)
2634 asection
*output_section
= htab
->elf
.sgotplt
->output_section
;
2636 if (bfd_is_abs_section (output_section
))
2638 (*_bfd_error_handler
)
2639 (_("discarded output section: `%pA'"), htab
->elf
.sgotplt
);
2643 if (htab
->elf
.sgotplt
->size
> 0)
2645 /* Write the first two entries in .got.plt, needed for the dynamic
2647 bfd_put_NN (output_bfd
, (bfd_vma
) -1, htab
->elf
.sgotplt
->contents
);
2648 bfd_put_NN (output_bfd
, (bfd_vma
) 0,
2649 htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
);
2652 elf_section_data (output_section
)->this_hdr
.sh_entsize
= GOT_ENTRY_SIZE
;
2657 asection
*output_section
= htab
->elf
.sgot
->output_section
;
2659 if (htab
->elf
.sgot
->size
> 0)
2661 /* Set the first entry in the global offset table to the address of
2662 the dynamic section. */
2663 bfd_vma val
= sdyn
? sec_addr (sdyn
) : 0;
2664 bfd_put_NN (output_bfd
, val
, htab
->elf
.sgot
->contents
);
2667 elf_section_data (output_section
)->this_hdr
.sh_entsize
= GOT_ENTRY_SIZE
;
2673 /* Return address for Ith PLT stub in section PLT, for relocation REL
2674 or (bfd_vma) -1 if it should not be included. */
2677 riscv_elf_plt_sym_val (bfd_vma i
, const asection
*plt
,
2678 const arelent
*rel ATTRIBUTE_UNUSED
)
2680 return plt
->vma
+ PLT_HEADER_SIZE
+ i
* PLT_ENTRY_SIZE
;
2683 static enum elf_reloc_type_class
2684 riscv_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2685 const asection
*rel_sec ATTRIBUTE_UNUSED
,
2686 const Elf_Internal_Rela
*rela
)
2688 switch (ELFNN_R_TYPE (rela
->r_info
))
2690 case R_RISCV_RELATIVE
:
2691 return reloc_class_relative
;
2692 case R_RISCV_JUMP_SLOT
:
2693 return reloc_class_plt
;
2695 return reloc_class_copy
;
2697 return reloc_class_normal
;
2701 /* Given the ELF header flags in FLAGS, it returns a string that describes the
2705 riscv_float_abi_string (flagword flags
)
2707 switch (flags
& EF_RISCV_FLOAT_ABI
)
2709 case EF_RISCV_FLOAT_ABI_SOFT
:
2710 return "soft-float";
2712 case EF_RISCV_FLOAT_ABI_SINGLE
:
2713 return "single-float";
2715 case EF_RISCV_FLOAT_ABI_DOUBLE
:
2716 return "double-float";
2718 case EF_RISCV_FLOAT_ABI_QUAD
:
2719 return "quad-float";
2726 /* The information of architecture attribute. */
2727 static riscv_subset_list_t in_subsets
;
2728 static riscv_subset_list_t out_subsets
;
2729 static riscv_subset_list_t merged_subsets
;
2731 /* Predicator for standard extension. */
2734 riscv_std_ext_p (const char *name
)
2736 return (strlen (name
) == 1) && (name
[0] != 'x') && (name
[0] != 's');
2739 /* Error handler when version mis-match. */
2742 riscv_version_mismatch (bfd
*ibfd
,
2743 struct riscv_subset_t
*in
,
2744 struct riscv_subset_t
*out
)
2747 (_("error: %pB: Mis-matched ISA version for '%s' extension. "
2750 in
->major_version
, in
->minor_version
,
2751 out
->major_version
, out
->minor_version
);
2754 /* Return true if subset is 'i' or 'e'. */
2757 riscv_i_or_e_p (bfd
*ibfd
,
2759 struct riscv_subset_t
*subset
)
2761 if ((strcasecmp (subset
->name
, "e") != 0)
2762 && (strcasecmp (subset
->name
, "i") != 0))
2765 (_("error: %pB: corrupted ISA string '%s'. "
2766 "First letter should be 'i' or 'e' but got '%s'."),
2767 ibfd
, arch
, subset
->name
);
2773 /* Merge standard extensions.
2776 Return FALSE if failed to merge.
2780 `in_arch`: Raw arch string for input object.
2781 `out_arch`: Raw arch string for output object.
2782 `pin`: subset list for input object, and it'll skip all merged subset after
2784 `pout`: Like `pin`, but for output object. */
2787 riscv_merge_std_ext (bfd
*ibfd
,
2788 const char *in_arch
,
2789 const char *out_arch
,
2790 struct riscv_subset_t
**pin
,
2791 struct riscv_subset_t
**pout
)
2793 const char *standard_exts
= riscv_supported_std_ext ();
2795 struct riscv_subset_t
*in
= *pin
;
2796 struct riscv_subset_t
*out
= *pout
;
2798 /* First letter should be 'i' or 'e'. */
2799 if (!riscv_i_or_e_p (ibfd
, in_arch
, in
))
2802 if (!riscv_i_or_e_p (ibfd
, out_arch
, out
))
2805 if (in
->name
[0] != out
->name
[0])
2807 /* TODO: We might allow merge 'i' with 'e'. */
2809 (_("error: %pB: Mis-matched ISA string to merge '%s' and '%s'."),
2810 ibfd
, in
->name
, out
->name
);
2813 else if ((in
->major_version
!= out
->major_version
) ||
2814 (in
->minor_version
!= out
->minor_version
))
2816 /* TODO: Allow different merge policy. */
2817 riscv_version_mismatch (ibfd
, in
, out
);
2821 riscv_add_subset (&merged_subsets
,
2822 in
->name
, in
->major_version
, in
->minor_version
);
2827 /* Handle standard extension first. */
2828 for (p
= standard_exts
; *p
; ++p
)
2830 char find_ext
[2] = {*p
, '\0'};
2831 struct riscv_subset_t
*find_in
=
2832 riscv_lookup_subset (&in_subsets
, find_ext
);
2833 struct riscv_subset_t
*find_out
=
2834 riscv_lookup_subset (&out_subsets
, find_ext
);
2836 if (find_in
== NULL
&& find_out
== NULL
)
2839 /* Check version is same or not. */
2840 /* TODO: Allow different merge policy. */
2841 if ((find_in
!= NULL
&& find_out
!= NULL
)
2842 && ((find_in
->major_version
!= find_out
->major_version
)
2843 || (find_in
->minor_version
!= find_out
->minor_version
)))
2845 riscv_version_mismatch (ibfd
, in
, out
);
2849 struct riscv_subset_t
*merged
= find_in
? find_in
: find_out
;
2850 riscv_add_subset (&merged_subsets
, merged
->name
,
2851 merged
->major_version
, merged
->minor_version
);
2854 /* Skip all standard extensions. */
2855 while ((in
!= NULL
) && riscv_std_ext_p (in
->name
)) in
= in
->next
;
2856 while ((out
!= NULL
) && riscv_std_ext_p (out
->name
)) out
= out
->next
;
2864 /* If C is a prefix class, then return the EXT string without the prefix.
2865 Otherwise return the entire EXT string. */
2868 riscv_skip_prefix (const char *ext
, riscv_isa_ext_class_t c
)
2872 case RV_ISA_CLASS_X
: return &ext
[1];
2873 case RV_ISA_CLASS_S
: return &ext
[1];
2874 case RV_ISA_CLASS_Z
: return &ext
[1];
2875 default: return ext
;
2879 /* Compare prefixed extension names canonically. */
2882 riscv_prefix_cmp (const char *a
, const char *b
)
2884 riscv_isa_ext_class_t ca
= riscv_get_prefix_class (a
);
2885 riscv_isa_ext_class_t cb
= riscv_get_prefix_class (b
);
2887 /* Extension name without prefix */
2888 const char *anp
= riscv_skip_prefix (a
, ca
);
2889 const char *bnp
= riscv_skip_prefix (b
, cb
);
2892 return strcasecmp (anp
, bnp
);
2894 return (int)ca
- (int)cb
;
2897 /* Merge multi letter extensions. PIN is a pointer to the head of the input
2898 object subset list. Likewise for POUT and the output object. Return TRUE
2899 on success and FALSE when a conflict is found. */
2902 riscv_merge_multi_letter_ext (bfd
*ibfd
,
2903 riscv_subset_t
**pin
,
2904 riscv_subset_t
**pout
)
2906 riscv_subset_t
*in
= *pin
;
2907 riscv_subset_t
*out
= *pout
;
2908 riscv_subset_t
*tail
;
2914 cmp
= riscv_prefix_cmp (in
->name
, out
->name
);
2918 /* `in' comes before `out', append `in' and increment. */
2919 riscv_add_subset (&merged_subsets
, in
->name
, in
->major_version
,
2925 /* `out' comes before `in', append `out' and increment. */
2926 riscv_add_subset (&merged_subsets
, out
->name
, out
->major_version
,
2927 out
->minor_version
);
2932 /* Both present, check version and increment both. */
2933 if ((in
->major_version
!= out
->major_version
)
2934 || (in
->minor_version
!= out
->minor_version
))
2936 riscv_version_mismatch (ibfd
, in
, out
);
2940 riscv_add_subset (&merged_subsets
, out
->name
, out
->major_version
,
2941 out
->minor_version
);
2948 /* If we're here, either `in' or `out' is running longer than
2949 the other. So, we need to append the corresponding tail. */
2950 tail
= in
? in
: out
;
2954 riscv_add_subset (&merged_subsets
, tail
->name
, tail
->major_version
,
2955 tail
->minor_version
);
2963 /* Merge Tag_RISCV_arch attribute. */
2966 riscv_merge_arch_attr_info (bfd
*ibfd
, char *in_arch
, char *out_arch
)
2968 riscv_subset_t
*in
, *out
;
2969 char *merged_arch_str
;
2971 unsigned xlen_in
, xlen_out
;
2972 merged_subsets
.head
= NULL
;
2973 merged_subsets
.tail
= NULL
;
2975 riscv_parse_subset_t rpe_in
;
2976 riscv_parse_subset_t rpe_out
;
2978 rpe_in
.subset_list
= &in_subsets
;
2979 rpe_in
.error_handler
= _bfd_error_handler
;
2980 rpe_in
.xlen
= &xlen_in
;
2982 rpe_out
.subset_list
= &out_subsets
;
2983 rpe_out
.error_handler
= _bfd_error_handler
;
2984 rpe_out
.xlen
= &xlen_out
;
2986 if (in_arch
== NULL
&& out_arch
== NULL
)
2989 if (in_arch
== NULL
&& out_arch
!= NULL
)
2992 if (in_arch
!= NULL
&& out_arch
== NULL
)
2995 /* Parse subset from arch string. */
2996 if (!riscv_parse_subset (&rpe_in
, in_arch
))
2999 if (!riscv_parse_subset (&rpe_out
, out_arch
))
3002 /* Checking XLEN. */
3003 if (xlen_out
!= xlen_in
)
3006 (_("error: %pB: ISA string of input (%s) doesn't match "
3007 "output (%s)."), ibfd
, in_arch
, out_arch
);
3011 /* Merge subset list. */
3012 in
= in_subsets
.head
;
3013 out
= out_subsets
.head
;
3015 /* Merge standard extension. */
3016 if (!riscv_merge_std_ext (ibfd
, in_arch
, out_arch
, &in
, &out
))
3019 /* Merge all non-single letter extensions with single call. */
3020 if (!riscv_merge_multi_letter_ext (ibfd
, &in
, &out
))
3023 if (xlen_in
!= xlen_out
)
3026 (_("error: %pB: XLEN of input (%u) doesn't match "
3027 "output (%u)."), ibfd
, xlen_in
, xlen_out
);
3031 if (xlen_in
!= ARCH_SIZE
)
3034 (_("error: %pB: Unsupported XLEN (%u), you might be "
3035 "using wrong emulation."), ibfd
, xlen_in
);
3039 merged_arch_str
= riscv_arch_str (ARCH_SIZE
, &merged_subsets
);
3041 /* Release the subset lists. */
3042 riscv_release_subset_list (&in_subsets
);
3043 riscv_release_subset_list (&out_subsets
);
3044 riscv_release_subset_list (&merged_subsets
);
3046 return merged_arch_str
;
3049 /* Merge object attributes from IBFD into output_bfd of INFO.
3050 Raise an error if there are conflicting attributes. */
3053 riscv_merge_attributes (bfd
*ibfd
, struct bfd_link_info
*info
)
3055 bfd
*obfd
= info
->output_bfd
;
3056 obj_attribute
*in_attr
;
3057 obj_attribute
*out_attr
;
3058 bfd_boolean result
= TRUE
;
3059 const char *sec_name
= get_elf_backend_data (ibfd
)->obj_attrs_section
;
3062 /* Skip linker created files. */
3063 if (ibfd
->flags
& BFD_LINKER_CREATED
)
3066 /* Skip any input that doesn't have an attribute section.
3067 This enables to link object files without attribute section with
3069 if (bfd_get_section_by_name (ibfd
, sec_name
) == NULL
)
3072 if (!elf_known_obj_attributes_proc (obfd
)[0].i
)
3074 /* This is the first object. Copy the attributes. */
3075 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
3077 out_attr
= elf_known_obj_attributes_proc (obfd
);
3079 /* Use the Tag_null value to indicate the attributes have been
3086 in_attr
= elf_known_obj_attributes_proc (ibfd
);
3087 out_attr
= elf_known_obj_attributes_proc (obfd
);
3089 for (i
= LEAST_KNOWN_OBJ_ATTRIBUTE
; i
< NUM_KNOWN_OBJ_ATTRIBUTES
; i
++)
3093 case Tag_RISCV_arch
:
3094 if (!out_attr
[Tag_RISCV_arch
].s
)
3095 out_attr
[Tag_RISCV_arch
].s
= in_attr
[Tag_RISCV_arch
].s
;
3096 else if (in_attr
[Tag_RISCV_arch
].s
3097 && out_attr
[Tag_RISCV_arch
].s
)
3099 /* Check arch compatible. */
3101 riscv_merge_arch_attr_info (ibfd
,
3102 in_attr
[Tag_RISCV_arch
].s
,
3103 out_attr
[Tag_RISCV_arch
].s
);
3104 if (merged_arch
== NULL
)
3107 out_attr
[Tag_RISCV_arch
].s
= "";
3110 out_attr
[Tag_RISCV_arch
].s
= merged_arch
;
3113 case Tag_RISCV_priv_spec
:
3114 case Tag_RISCV_priv_spec_minor
:
3115 case Tag_RISCV_priv_spec_revision
:
3116 if (out_attr
[i
].i
!= in_attr
[i
].i
)
3119 (_("error: %pB: conflicting priv spec version "
3120 "(major/minor/revision)."), ibfd
);
3124 case Tag_RISCV_unaligned_access
:
3125 out_attr
[i
].i
|= in_attr
[i
].i
;
3127 case Tag_RISCV_stack_align
:
3128 if (out_attr
[i
].i
== 0)
3129 out_attr
[i
].i
= in_attr
[i
].i
;
3130 else if (in_attr
[i
].i
!= 0
3131 && out_attr
[i
].i
!= 0
3132 && out_attr
[i
].i
!= in_attr
[i
].i
)
3135 (_("error: %pB use %u-byte stack aligned but the output "
3136 "use %u-byte stack aligned."),
3137 ibfd
, in_attr
[i
].i
, out_attr
[i
].i
);
3142 result
&= _bfd_elf_merge_unknown_attribute_low (ibfd
, obfd
, i
);
3145 /* If out_attr was copied from in_attr then it won't have a type yet. */
3146 if (in_attr
[i
].type
&& !out_attr
[i
].type
)
3147 out_attr
[i
].type
= in_attr
[i
].type
;
3150 /* Merge Tag_compatibility attributes and any common GNU ones. */
3151 if (!_bfd_elf_merge_object_attributes (ibfd
, info
))
3154 /* Check for any attributes not known on RISC-V. */
3155 result
&= _bfd_elf_merge_unknown_attribute_list (ibfd
, obfd
);
3160 /* Merge backend specific data from an object file to the output
3161 object file when linking. */
3164 _bfd_riscv_elf_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
3166 bfd
*obfd
= info
->output_bfd
;
3167 flagword new_flags
, old_flags
;
3169 if (!is_riscv_elf (ibfd
) || !is_riscv_elf (obfd
))
3172 if (strcmp (bfd_get_target (ibfd
), bfd_get_target (obfd
)) != 0)
3174 (*_bfd_error_handler
)
3175 (_("%pB: ABI is incompatible with that of the selected emulation:\n"
3176 " target emulation `%s' does not match `%s'"),
3177 ibfd
, bfd_get_target (ibfd
), bfd_get_target (obfd
));
3181 if (!_bfd_elf_merge_object_attributes (ibfd
, info
))
3184 if (!riscv_merge_attributes (ibfd
, info
))
3187 new_flags
= elf_elfheader (ibfd
)->e_flags
;
3188 old_flags
= elf_elfheader (obfd
)->e_flags
;
3190 if (! elf_flags_init (obfd
))
3192 elf_flags_init (obfd
) = TRUE
;
3193 elf_elfheader (obfd
)->e_flags
= new_flags
;
3197 /* Check to see if the input BFD actually contains any sections. If not,
3198 its flags may not have been initialized either, but it cannot actually
3199 cause any incompatibility. Do not short-circuit dynamic objects; their
3200 section list may be emptied by elf_link_add_object_symbols.
3202 Also check to see if there are no code sections in the input. In this
3203 case, there is no need to check for code specific flags. */
3204 if (!(ibfd
->flags
& DYNAMIC
))
3206 bfd_boolean null_input_bfd
= TRUE
;
3207 bfd_boolean only_data_sections
= TRUE
;
3210 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
3212 if ((bfd_section_flags (sec
)
3213 & (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
3214 == (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
3215 only_data_sections
= FALSE
;
3217 null_input_bfd
= FALSE
;
3221 if (null_input_bfd
|| only_data_sections
)
3225 /* Disallow linking different float ABIs. */
3226 if ((old_flags
^ new_flags
) & EF_RISCV_FLOAT_ABI
)
3228 (*_bfd_error_handler
)
3229 (_("%pB: can't link %s modules with %s modules"), ibfd
,
3230 riscv_float_abi_string (new_flags
),
3231 riscv_float_abi_string (old_flags
));
3235 /* Disallow linking RVE and non-RVE. */
3236 if ((old_flags
^ new_flags
) & EF_RISCV_RVE
)
3238 (*_bfd_error_handler
)
3239 (_("%pB: can't link RVE with other target"), ibfd
);
3243 /* Allow linking RVC and non-RVC, and keep the RVC flag. */
3244 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_RISCV_RVC
;
3249 bfd_set_error (bfd_error_bad_value
);
3253 /* Delete some bytes from a section while relaxing. */
3256 riscv_relax_delete_bytes (bfd
*abfd
, asection
*sec
, bfd_vma addr
, size_t count
,
3257 struct bfd_link_info
*link_info
)
3259 unsigned int i
, symcount
;
3260 bfd_vma toaddr
= sec
->size
;
3261 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (abfd
);
3262 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3263 unsigned int sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
3264 struct bfd_elf_section_data
*data
= elf_section_data (sec
);
3265 bfd_byte
*contents
= data
->this_hdr
.contents
;
3267 /* Actually delete the bytes. */
3269 memmove (contents
+ addr
, contents
+ addr
+ count
, toaddr
- addr
- count
);
3271 /* Adjust the location of all of the relocs. Note that we need not
3272 adjust the addends, since all PC-relative references must be against
3273 symbols, which we will adjust below. */
3274 for (i
= 0; i
< sec
->reloc_count
; i
++)
3275 if (data
->relocs
[i
].r_offset
> addr
&& data
->relocs
[i
].r_offset
< toaddr
)
3276 data
->relocs
[i
].r_offset
-= count
;
3278 /* Adjust the local symbols defined in this section. */
3279 for (i
= 0; i
< symtab_hdr
->sh_info
; i
++)
3281 Elf_Internal_Sym
*sym
= (Elf_Internal_Sym
*) symtab_hdr
->contents
+ i
;
3282 if (sym
->st_shndx
== sec_shndx
)
3284 /* If the symbol is in the range of memory we just moved, we
3285 have to adjust its value. */
3286 if (sym
->st_value
> addr
&& sym
->st_value
<= toaddr
)
3287 sym
->st_value
-= count
;
3289 /* If the symbol *spans* the bytes we just deleted (i.e. its
3290 *end* is in the moved bytes but its *start* isn't), then we
3291 must adjust its size.
3293 This test needs to use the original value of st_value, otherwise
3294 we might accidentally decrease size when deleting bytes right
3295 before the symbol. But since deleted relocs can't span across
3296 symbols, we can't have both a st_value and a st_size decrease,
3297 so it is simpler to just use an else. */
3298 else if (sym
->st_value
<= addr
3299 && sym
->st_value
+ sym
->st_size
> addr
3300 && sym
->st_value
+ sym
->st_size
<= toaddr
)
3301 sym
->st_size
-= count
;
3305 /* Now adjust the global symbols defined in this section. */
3306 symcount
= ((symtab_hdr
->sh_size
/ sizeof (ElfNN_External_Sym
))
3307 - symtab_hdr
->sh_info
);
3309 for (i
= 0; i
< symcount
; i
++)
3311 struct elf_link_hash_entry
*sym_hash
= sym_hashes
[i
];
3313 /* The '--wrap SYMBOL' option is causing a pain when the object file,
3314 containing the definition of __wrap_SYMBOL, includes a direct
3315 call to SYMBOL as well. Since both __wrap_SYMBOL and SYMBOL reference
3316 the same symbol (which is __wrap_SYMBOL), but still exist as two
3317 different symbols in 'sym_hashes', we don't want to adjust
3318 the global symbol __wrap_SYMBOL twice. */
3319 /* The same problem occurs with symbols that are versioned_hidden, as
3320 foo becomes an alias for foo@BAR, and hence they need the same
3322 if (link_info
->wrap_hash
!= NULL
3323 || sym_hash
->versioned
== versioned_hidden
)
3325 struct elf_link_hash_entry
**cur_sym_hashes
;
3327 /* Loop only over the symbols which have already been checked. */
3328 for (cur_sym_hashes
= sym_hashes
; cur_sym_hashes
< &sym_hashes
[i
];
3331 /* If the current symbol is identical to 'sym_hash', that means
3332 the symbol was already adjusted (or at least checked). */
3333 if (*cur_sym_hashes
== sym_hash
)
3336 /* Don't adjust the symbol again. */
3337 if (cur_sym_hashes
< &sym_hashes
[i
])
3341 if ((sym_hash
->root
.type
== bfd_link_hash_defined
3342 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
3343 && sym_hash
->root
.u
.def
.section
== sec
)
3345 /* As above, adjust the value if needed. */
3346 if (sym_hash
->root
.u
.def
.value
> addr
3347 && sym_hash
->root
.u
.def
.value
<= toaddr
)
3348 sym_hash
->root
.u
.def
.value
-= count
;
3350 /* As above, adjust the size if needed. */
3351 else if (sym_hash
->root
.u
.def
.value
<= addr
3352 && sym_hash
->root
.u
.def
.value
+ sym_hash
->size
> addr
3353 && sym_hash
->root
.u
.def
.value
+ sym_hash
->size
<= toaddr
)
3354 sym_hash
->size
-= count
;
3361 /* A second format for recording PC-relative hi relocations. This stores the
3362 information required to relax them to GP-relative addresses. */
3364 typedef struct riscv_pcgp_hi_reloc riscv_pcgp_hi_reloc
;
3365 struct riscv_pcgp_hi_reloc
3372 bfd_boolean undefined_weak
;
3373 riscv_pcgp_hi_reloc
*next
;
3376 typedef struct riscv_pcgp_lo_reloc riscv_pcgp_lo_reloc
;
3377 struct riscv_pcgp_lo_reloc
3380 riscv_pcgp_lo_reloc
*next
;
3385 riscv_pcgp_hi_reloc
*hi
;
3386 riscv_pcgp_lo_reloc
*lo
;
3387 } riscv_pcgp_relocs
;
3389 /* Initialize the pcgp reloc info in P. */
3392 riscv_init_pcgp_relocs (riscv_pcgp_relocs
*p
)
3399 /* Free the pcgp reloc info in P. */
3402 riscv_free_pcgp_relocs (riscv_pcgp_relocs
*p
,
3403 bfd
*abfd ATTRIBUTE_UNUSED
,
3404 asection
*sec ATTRIBUTE_UNUSED
)
3406 riscv_pcgp_hi_reloc
*c
;
3407 riscv_pcgp_lo_reloc
*l
;
3409 for (c
= p
->hi
; c
!= NULL
;)
3411 riscv_pcgp_hi_reloc
*next
= c
->next
;
3416 for (l
= p
->lo
; l
!= NULL
;)
3418 riscv_pcgp_lo_reloc
*next
= l
->next
;
3424 /* Record pcgp hi part reloc info in P, using HI_SEC_OFF as the lookup index.
3425 The HI_ADDEND, HI_ADDR, HI_SYM, and SYM_SEC args contain info required to
3426 relax the corresponding lo part reloc. */
3429 riscv_record_pcgp_hi_reloc (riscv_pcgp_relocs
*p
, bfd_vma hi_sec_off
,
3430 bfd_vma hi_addend
, bfd_vma hi_addr
,
3431 unsigned hi_sym
, asection
*sym_sec
,
3432 bfd_boolean undefined_weak
)
3434 riscv_pcgp_hi_reloc
*new = bfd_malloc (sizeof(*new));
3437 new->hi_sec_off
= hi_sec_off
;
3438 new->hi_addend
= hi_addend
;
3439 new->hi_addr
= hi_addr
;
3440 new->hi_sym
= hi_sym
;
3441 new->sym_sec
= sym_sec
;
3442 new->undefined_weak
= undefined_weak
;
3448 /* Look up hi part pcgp reloc info in P, using HI_SEC_OFF as the lookup index.
3449 This is used by a lo part reloc to find the corresponding hi part reloc. */
3451 static riscv_pcgp_hi_reloc
*
3452 riscv_find_pcgp_hi_reloc(riscv_pcgp_relocs
*p
, bfd_vma hi_sec_off
)
3454 riscv_pcgp_hi_reloc
*c
;
3456 for (c
= p
->hi
; c
!= NULL
; c
= c
->next
)
3457 if (c
->hi_sec_off
== hi_sec_off
)
3462 /* Record pcgp lo part reloc info in P, using HI_SEC_OFF as the lookup info.
3463 This is used to record relocs that can't be relaxed. */
3466 riscv_record_pcgp_lo_reloc (riscv_pcgp_relocs
*p
, bfd_vma hi_sec_off
)
3468 riscv_pcgp_lo_reloc
*new = bfd_malloc (sizeof(*new));
3471 new->hi_sec_off
= hi_sec_off
;
3477 /* Look up lo part pcgp reloc info in P, using HI_SEC_OFF as the lookup index.
3478 This is used by a hi part reloc to find the corresponding lo part reloc. */
3481 riscv_find_pcgp_lo_reloc (riscv_pcgp_relocs
*p
, bfd_vma hi_sec_off
)
3483 riscv_pcgp_lo_reloc
*c
;
3485 for (c
= p
->lo
; c
!= NULL
; c
= c
->next
)
3486 if (c
->hi_sec_off
== hi_sec_off
)
3491 typedef bfd_boolean (*relax_func_t
) (bfd
*, asection
*, asection
*,
3492 struct bfd_link_info
*,
3493 Elf_Internal_Rela
*,
3494 bfd_vma
, bfd_vma
, bfd_vma
, bfd_boolean
*,
3495 riscv_pcgp_relocs
*,
3496 bfd_boolean undefined_weak
);
3498 /* Relax AUIPC + JALR into JAL. */
3501 _bfd_riscv_relax_call (bfd
*abfd
, asection
*sec
, asection
*sym_sec
,
3502 struct bfd_link_info
*link_info
,
3503 Elf_Internal_Rela
*rel
,
3505 bfd_vma max_alignment
,
3506 bfd_vma reserve_size ATTRIBUTE_UNUSED
,
3508 riscv_pcgp_relocs
*pcgp_relocs ATTRIBUTE_UNUSED
,
3509 bfd_boolean undefined_weak ATTRIBUTE_UNUSED
)
3511 bfd_byte
*contents
= elf_section_data (sec
)->this_hdr
.contents
;
3512 bfd_signed_vma foff
= symval
- (sec_addr (sec
) + rel
->r_offset
);
3513 bfd_boolean near_zero
= (symval
+ RISCV_IMM_REACH
/2) < RISCV_IMM_REACH
;
3514 bfd_vma auipc
, jalr
;
3515 int rd
, r_type
, len
= 4, rvc
= elf_elfheader (abfd
)->e_flags
& EF_RISCV_RVC
;
3517 /* If the call crosses section boundaries, an alignment directive could
3518 cause the PC-relative offset to later increase, so we need to add in the
3519 max alignment of any section inclusive from the call to the target.
3520 Otherwise, we only need to use the alignment of the current section. */
3521 if (VALID_UJTYPE_IMM (foff
))
3523 if (sym_sec
->output_section
== sec
->output_section
3524 && sym_sec
->output_section
!= bfd_abs_section_ptr
)
3525 max_alignment
= (bfd_vma
) 1 << sym_sec
->output_section
->alignment_power
;
3526 foff
+= (foff
< 0 ? -max_alignment
: max_alignment
);
3529 /* See if this function call can be shortened. */
3530 if (!VALID_UJTYPE_IMM (foff
) && !(!bfd_link_pic (link_info
) && near_zero
))
3533 /* Shorten the function call. */
3534 BFD_ASSERT (rel
->r_offset
+ 8 <= sec
->size
);
3536 auipc
= bfd_get_32 (abfd
, contents
+ rel
->r_offset
);
3537 jalr
= bfd_get_32 (abfd
, contents
+ rel
->r_offset
+ 4);
3538 rd
= (jalr
>> OP_SH_RD
) & OP_MASK_RD
;
3539 rvc
= rvc
&& VALID_RVC_J_IMM (foff
);
3541 /* C.J exists on RV32 and RV64, but C.JAL is RV32-only. */
3542 rvc
= rvc
&& (rd
== 0 || (rd
== X_RA
&& ARCH_SIZE
== 32));
3546 /* Relax to C.J[AL] rd, addr. */
3547 r_type
= R_RISCV_RVC_JUMP
;
3548 auipc
= rd
== 0 ? MATCH_C_J
: MATCH_C_JAL
;
3551 else if (VALID_UJTYPE_IMM (foff
))
3553 /* Relax to JAL rd, addr. */
3554 r_type
= R_RISCV_JAL
;
3555 auipc
= MATCH_JAL
| (rd
<< OP_SH_RD
);
3557 else /* near_zero */
3559 /* Relax to JALR rd, x0, addr. */
3560 r_type
= R_RISCV_LO12_I
;
3561 auipc
= MATCH_JALR
| (rd
<< OP_SH_RD
);
3564 /* Replace the R_RISCV_CALL reloc. */
3565 rel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (rel
->r_info
), r_type
);
3566 /* Replace the AUIPC. */
3567 bfd_put (8 * len
, abfd
, auipc
, contents
+ rel
->r_offset
);
3569 /* Delete unnecessary JALR. */
3571 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
+ len
, 8 - len
,
3575 /* Traverse all output sections and return the max alignment. */
3578 _bfd_riscv_get_max_alignment (asection
*sec
)
3580 unsigned int max_alignment_power
= 0;
3583 for (o
= sec
->output_section
->owner
->sections
; o
!= NULL
; o
= o
->next
)
3585 if (o
->alignment_power
> max_alignment_power
)
3586 max_alignment_power
= o
->alignment_power
;
3589 return (bfd_vma
) 1 << max_alignment_power
;
3592 /* Relax non-PIC global variable references. */
3595 _bfd_riscv_relax_lui (bfd
*abfd
,
3598 struct bfd_link_info
*link_info
,
3599 Elf_Internal_Rela
*rel
,
3601 bfd_vma max_alignment
,
3602 bfd_vma reserve_size
,
3604 riscv_pcgp_relocs
*pcgp_relocs ATTRIBUTE_UNUSED
,
3605 bfd_boolean undefined_weak
)
3607 bfd_byte
*contents
= elf_section_data (sec
)->this_hdr
.contents
;
3608 bfd_vma gp
= riscv_global_pointer_value (link_info
);
3609 int use_rvc
= elf_elfheader (abfd
)->e_flags
& EF_RISCV_RVC
;
3611 BFD_ASSERT (rel
->r_offset
+ 4 <= sec
->size
);
3615 /* If gp and the symbol are in the same output section, which is not the
3616 abs section, then consider only that output section's alignment. */
3617 struct bfd_link_hash_entry
*h
=
3618 bfd_link_hash_lookup (link_info
->hash
, RISCV_GP_SYMBOL
, FALSE
, FALSE
,
3620 if (h
->u
.def
.section
->output_section
== sym_sec
->output_section
3621 && sym_sec
->output_section
!= bfd_abs_section_ptr
)
3622 max_alignment
= (bfd_vma
) 1 << sym_sec
->output_section
->alignment_power
;
3625 /* Is the reference in range of x0 or gp?
3626 Valid gp range conservatively because of alignment issue. */
3628 || (VALID_ITYPE_IMM (symval
)
3630 && VALID_ITYPE_IMM (symval
- gp
+ max_alignment
+ reserve_size
))
3632 && VALID_ITYPE_IMM (symval
- gp
- max_alignment
- reserve_size
))))
3634 unsigned sym
= ELFNN_R_SYM (rel
->r_info
);
3635 switch (ELFNN_R_TYPE (rel
->r_info
))
3637 case R_RISCV_LO12_I
:
3640 /* Change the RS1 to zero. */
3641 bfd_vma insn
= bfd_get_32 (abfd
, contents
+ rel
->r_offset
);
3642 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
3643 bfd_put_32 (abfd
, insn
, contents
+ rel
->r_offset
);
3646 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_GPREL_I
);
3649 case R_RISCV_LO12_S
:
3652 /* Change the RS1 to zero. */
3653 bfd_vma insn
= bfd_get_32 (abfd
, contents
+ rel
->r_offset
);
3654 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
3655 bfd_put_32 (abfd
, insn
, contents
+ rel
->r_offset
);
3658 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_GPREL_S
);
3662 /* We can delete the unnecessary LUI and reloc. */
3663 rel
->r_info
= ELFNN_R_INFO (0, R_RISCV_NONE
);
3665 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
, 4,
3673 /* Can we relax LUI to C.LUI? Alignment might move the section forward;
3674 account for this assuming page alignment at worst. In the presence of
3675 RELRO segment the linker aligns it by one page size, therefore sections
3676 after the segment can be moved more than one page. */
3679 && ELFNN_R_TYPE (rel
->r_info
) == R_RISCV_HI20
3680 && VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (symval
))
3681 && VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (symval
)
3682 + (link_info
->relro
? 2 * ELF_MAXPAGESIZE
3683 : ELF_MAXPAGESIZE
)))
3685 /* Replace LUI with C.LUI if legal (i.e., rd != x0 and rd != x2/sp). */
3686 bfd_vma lui
= bfd_get_32 (abfd
, contents
+ rel
->r_offset
);
3687 unsigned rd
= ((unsigned)lui
>> OP_SH_RD
) & OP_MASK_RD
;
3688 if (rd
== 0 || rd
== X_SP
)
3691 lui
= (lui
& (OP_MASK_RD
<< OP_SH_RD
)) | MATCH_C_LUI
;
3692 bfd_put_32 (abfd
, lui
, contents
+ rel
->r_offset
);
3694 /* Replace the R_RISCV_HI20 reloc. */
3695 rel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (rel
->r_info
), R_RISCV_RVC_LUI
);
3698 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
+ 2, 2,
3705 /* Relax non-PIC TLS references. */
3708 _bfd_riscv_relax_tls_le (bfd
*abfd
,
3710 asection
*sym_sec ATTRIBUTE_UNUSED
,
3711 struct bfd_link_info
*link_info
,
3712 Elf_Internal_Rela
*rel
,
3714 bfd_vma max_alignment ATTRIBUTE_UNUSED
,
3715 bfd_vma reserve_size ATTRIBUTE_UNUSED
,
3717 riscv_pcgp_relocs
*prcel_relocs ATTRIBUTE_UNUSED
,
3718 bfd_boolean undefined_weak ATTRIBUTE_UNUSED
)
3720 /* See if this symbol is in range of tp. */
3721 if (RISCV_CONST_HIGH_PART (tpoff (link_info
, symval
)) != 0)
3724 BFD_ASSERT (rel
->r_offset
+ 4 <= sec
->size
);
3725 switch (ELFNN_R_TYPE (rel
->r_info
))
3727 case R_RISCV_TPREL_LO12_I
:
3728 rel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (rel
->r_info
), R_RISCV_TPREL_I
);
3731 case R_RISCV_TPREL_LO12_S
:
3732 rel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (rel
->r_info
), R_RISCV_TPREL_S
);
3735 case R_RISCV_TPREL_HI20
:
3736 case R_RISCV_TPREL_ADD
:
3737 /* We can delete the unnecessary instruction and reloc. */
3738 rel
->r_info
= ELFNN_R_INFO (0, R_RISCV_NONE
);
3740 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
, 4, link_info
);
3747 /* Implement R_RISCV_ALIGN by deleting excess alignment NOPs. */
3750 _bfd_riscv_relax_align (bfd
*abfd
, asection
*sec
,
3752 struct bfd_link_info
*link_info
,
3753 Elf_Internal_Rela
*rel
,
3755 bfd_vma max_alignment ATTRIBUTE_UNUSED
,
3756 bfd_vma reserve_size ATTRIBUTE_UNUSED
,
3757 bfd_boolean
*again ATTRIBUTE_UNUSED
,
3758 riscv_pcgp_relocs
*pcrel_relocs ATTRIBUTE_UNUSED
,
3759 bfd_boolean undefined_weak ATTRIBUTE_UNUSED
)
3761 bfd_byte
*contents
= elf_section_data (sec
)->this_hdr
.contents
;
3762 bfd_vma alignment
= 1, pos
;
3763 while (alignment
<= rel
->r_addend
)
3766 symval
-= rel
->r_addend
;
3767 bfd_vma aligned_addr
= ((symval
- 1) & ~(alignment
- 1)) + alignment
;
3768 bfd_vma nop_bytes
= aligned_addr
- symval
;
3770 /* Once we've handled an R_RISCV_ALIGN, we can't relax anything else. */
3771 sec
->sec_flg0
= TRUE
;
3773 /* Make sure there are enough NOPs to actually achieve the alignment. */
3774 if (rel
->r_addend
< nop_bytes
)
3777 (_("%pB(%pA+%#" PRIx64
"): %" PRId64
" bytes required for alignment "
3778 "to %" PRId64
"-byte boundary, but only %" PRId64
" present"),
3779 abfd
, sym_sec
, (uint64_t) rel
->r_offset
,
3780 (int64_t) nop_bytes
, (int64_t) alignment
, (int64_t) rel
->r_addend
);
3781 bfd_set_error (bfd_error_bad_value
);
3785 /* Delete the reloc. */
3786 rel
->r_info
= ELFNN_R_INFO (0, R_RISCV_NONE
);
3788 /* If the number of NOPs is already correct, there's nothing to do. */
3789 if (nop_bytes
== rel
->r_addend
)
3792 /* Write as many RISC-V NOPs as we need. */
3793 for (pos
= 0; pos
< (nop_bytes
& -4); pos
+= 4)
3794 bfd_put_32 (abfd
, RISCV_NOP
, contents
+ rel
->r_offset
+ pos
);
3796 /* Write a final RVC NOP if need be. */
3797 if (nop_bytes
% 4 != 0)
3798 bfd_put_16 (abfd
, RVC_NOP
, contents
+ rel
->r_offset
+ pos
);
3800 /* Delete the excess bytes. */
3801 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
+ nop_bytes
,
3802 rel
->r_addend
- nop_bytes
, link_info
);
3805 /* Relax PC-relative references to GP-relative references. */
3808 _bfd_riscv_relax_pc (bfd
*abfd ATTRIBUTE_UNUSED
,
3811 struct bfd_link_info
*link_info
,
3812 Elf_Internal_Rela
*rel
,
3814 bfd_vma max_alignment
,
3815 bfd_vma reserve_size
,
3816 bfd_boolean
*again ATTRIBUTE_UNUSED
,
3817 riscv_pcgp_relocs
*pcgp_relocs
,
3818 bfd_boolean undefined_weak
)
3820 bfd_byte
*contents
= elf_section_data (sec
)->this_hdr
.contents
;
3821 bfd_vma gp
= riscv_global_pointer_value (link_info
);
3823 BFD_ASSERT (rel
->r_offset
+ 4 <= sec
->size
);
3825 /* Chain the _LO relocs to their cooresponding _HI reloc to compute the
3826 * actual target address. */
3827 riscv_pcgp_hi_reloc hi_reloc
;
3828 memset (&hi_reloc
, 0, sizeof (hi_reloc
));
3829 switch (ELFNN_R_TYPE (rel
->r_info
))
3831 case R_RISCV_PCREL_LO12_I
:
3832 case R_RISCV_PCREL_LO12_S
:
3834 /* If the %lo has an addend, it isn't for the label pointing at the
3835 hi part instruction, but rather for the symbol pointed at by the
3836 hi part instruction. So we must subtract it here for the lookup.
3837 It is still used below in the final symbol address. */
3838 bfd_vma hi_sec_off
= symval
- sec_addr (sym_sec
) - rel
->r_addend
;
3839 riscv_pcgp_hi_reloc
*hi
= riscv_find_pcgp_hi_reloc (pcgp_relocs
,
3843 riscv_record_pcgp_lo_reloc (pcgp_relocs
, hi_sec_off
);
3848 symval
= hi_reloc
.hi_addr
;
3849 sym_sec
= hi_reloc
.sym_sec
;
3851 /* We can not know whether the undefined weak symbol is referenced
3852 according to the information of R_RISCV_PCREL_LO12_I/S. Therefore,
3853 we have to record the 'undefined_weak' flag when handling the
3854 corresponding R_RISCV_HI20 reloc in riscv_record_pcgp_hi_reloc. */
3855 undefined_weak
= hi_reloc
.undefined_weak
;
3859 case R_RISCV_PCREL_HI20
:
3860 /* Mergeable symbols and code might later move out of range. */
3861 if (! undefined_weak
3862 && sym_sec
->flags
& (SEC_MERGE
| SEC_CODE
))
3865 /* If the cooresponding lo relocation has already been seen then it's not
3866 * safe to relax this relocation. */
3867 if (riscv_find_pcgp_lo_reloc (pcgp_relocs
, rel
->r_offset
))
3878 /* If gp and the symbol are in the same output section, which is not the
3879 abs section, then consider only that output section's alignment. */
3880 struct bfd_link_hash_entry
*h
=
3881 bfd_link_hash_lookup (link_info
->hash
, RISCV_GP_SYMBOL
, FALSE
, FALSE
,
3883 if (h
->u
.def
.section
->output_section
== sym_sec
->output_section
3884 && sym_sec
->output_section
!= bfd_abs_section_ptr
)
3885 max_alignment
= (bfd_vma
) 1 << sym_sec
->output_section
->alignment_power
;
3888 /* Is the reference in range of x0 or gp?
3889 Valid gp range conservatively because of alignment issue. */
3891 || (VALID_ITYPE_IMM (symval
)
3893 && VALID_ITYPE_IMM (symval
- gp
+ max_alignment
+ reserve_size
))
3895 && VALID_ITYPE_IMM (symval
- gp
- max_alignment
- reserve_size
))))
3897 unsigned sym
= hi_reloc
.hi_sym
;
3898 switch (ELFNN_R_TYPE (rel
->r_info
))
3900 case R_RISCV_PCREL_LO12_I
:
3903 /* Change the RS1 to zero, and then modify the relocation
3904 type to R_RISCV_LO12_I. */
3905 bfd_vma insn
= bfd_get_32 (abfd
, contents
+ rel
->r_offset
);
3906 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
3907 bfd_put_32 (abfd
, insn
, contents
+ rel
->r_offset
);
3908 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_LO12_I
);
3909 rel
->r_addend
= hi_reloc
.hi_addend
;
3913 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_GPREL_I
);
3914 rel
->r_addend
+= hi_reloc
.hi_addend
;
3918 case R_RISCV_PCREL_LO12_S
:
3921 /* Change the RS1 to zero, and then modify the relocation
3922 type to R_RISCV_LO12_S. */
3923 bfd_vma insn
= bfd_get_32 (abfd
, contents
+ rel
->r_offset
);
3924 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
3925 bfd_put_32 (abfd
, insn
, contents
+ rel
->r_offset
);
3926 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_LO12_S
);
3927 rel
->r_addend
= hi_reloc
.hi_addend
;
3931 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_GPREL_S
);
3932 rel
->r_addend
+= hi_reloc
.hi_addend
;
3936 case R_RISCV_PCREL_HI20
:
3937 riscv_record_pcgp_hi_reloc (pcgp_relocs
,
3941 ELFNN_R_SYM(rel
->r_info
),
3944 /* We can delete the unnecessary AUIPC and reloc. */
3945 rel
->r_info
= ELFNN_R_INFO (0, R_RISCV_DELETE
);
3957 /* Relax PC-relative references to GP-relative references. */
3960 _bfd_riscv_relax_delete (bfd
*abfd
,
3962 asection
*sym_sec ATTRIBUTE_UNUSED
,
3963 struct bfd_link_info
*link_info
,
3964 Elf_Internal_Rela
*rel
,
3965 bfd_vma symval ATTRIBUTE_UNUSED
,
3966 bfd_vma max_alignment ATTRIBUTE_UNUSED
,
3967 bfd_vma reserve_size ATTRIBUTE_UNUSED
,
3968 bfd_boolean
*again ATTRIBUTE_UNUSED
,
3969 riscv_pcgp_relocs
*pcgp_relocs ATTRIBUTE_UNUSED
,
3970 bfd_boolean undefined_weak ATTRIBUTE_UNUSED
)
3972 if (!riscv_relax_delete_bytes(abfd
, sec
, rel
->r_offset
, rel
->r_addend
,
3975 rel
->r_info
= ELFNN_R_INFO(0, R_RISCV_NONE
);
3979 /* Relax a section. Pass 0 shortens code sequences unless disabled. Pass 1
3980 deletes the bytes that pass 0 made obselete. Pass 2, which cannot be
3981 disabled, handles code alignment directives. */
3984 _bfd_riscv_relax_section (bfd
*abfd
, asection
*sec
,
3985 struct bfd_link_info
*info
,
3988 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (abfd
);
3989 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
3990 struct bfd_elf_section_data
*data
= elf_section_data (sec
);
3991 Elf_Internal_Rela
*relocs
;
3992 bfd_boolean ret
= FALSE
;
3994 bfd_vma max_alignment
, reserve_size
= 0;
3995 riscv_pcgp_relocs pcgp_relocs
;
3999 if (bfd_link_relocatable (info
)
4001 || (sec
->flags
& SEC_RELOC
) == 0
4002 || sec
->reloc_count
== 0
4003 || (info
->disable_target_specific_optimizations
4004 && info
->relax_pass
== 0))
4007 riscv_init_pcgp_relocs (&pcgp_relocs
);
4009 /* Read this BFD's relocs if we haven't done so already. */
4011 relocs
= data
->relocs
;
4012 else if (!(relocs
= _bfd_elf_link_read_relocs (abfd
, sec
, NULL
, NULL
,
4013 info
->keep_memory
)))
4018 max_alignment
= htab
->max_alignment
;
4019 if (max_alignment
== (bfd_vma
) -1)
4021 max_alignment
= _bfd_riscv_get_max_alignment (sec
);
4022 htab
->max_alignment
= max_alignment
;
4026 max_alignment
= _bfd_riscv_get_max_alignment (sec
);
4028 /* Examine and consider relaxing each reloc. */
4029 for (i
= 0; i
< sec
->reloc_count
; i
++)
4032 Elf_Internal_Rela
*rel
= relocs
+ i
;
4033 relax_func_t relax_func
;
4034 int type
= ELFNN_R_TYPE (rel
->r_info
);
4037 bfd_boolean undefined_weak
= FALSE
;
4040 if (info
->relax_pass
== 0)
4042 if (type
== R_RISCV_CALL
|| type
== R_RISCV_CALL_PLT
)
4043 relax_func
= _bfd_riscv_relax_call
;
4044 else if (type
== R_RISCV_HI20
4045 || type
== R_RISCV_LO12_I
4046 || type
== R_RISCV_LO12_S
)
4047 relax_func
= _bfd_riscv_relax_lui
;
4048 else if (!bfd_link_pic(info
)
4049 && (type
== R_RISCV_PCREL_HI20
4050 || type
== R_RISCV_PCREL_LO12_I
4051 || type
== R_RISCV_PCREL_LO12_S
))
4052 relax_func
= _bfd_riscv_relax_pc
;
4053 else if (type
== R_RISCV_TPREL_HI20
4054 || type
== R_RISCV_TPREL_ADD
4055 || type
== R_RISCV_TPREL_LO12_I
4056 || type
== R_RISCV_TPREL_LO12_S
)
4057 relax_func
= _bfd_riscv_relax_tls_le
;
4061 /* Only relax this reloc if it is paired with R_RISCV_RELAX. */
4062 if (i
== sec
->reloc_count
- 1
4063 || ELFNN_R_TYPE ((rel
+ 1)->r_info
) != R_RISCV_RELAX
4064 || rel
->r_offset
!= (rel
+ 1)->r_offset
)
4067 /* Skip over the R_RISCV_RELAX. */
4070 else if (info
->relax_pass
== 1 && type
== R_RISCV_DELETE
)
4071 relax_func
= _bfd_riscv_relax_delete
;
4072 else if (info
->relax_pass
== 2 && type
== R_RISCV_ALIGN
)
4073 relax_func
= _bfd_riscv_relax_align
;
4077 data
->relocs
= relocs
;
4079 /* Read this BFD's contents if we haven't done so already. */
4080 if (!data
->this_hdr
.contents
4081 && !bfd_malloc_and_get_section (abfd
, sec
, &data
->this_hdr
.contents
))
4084 /* Read this BFD's symbols if we haven't done so already. */
4085 if (symtab_hdr
->sh_info
!= 0
4086 && !symtab_hdr
->contents
4087 && !(symtab_hdr
->contents
=
4088 (unsigned char *) bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
4089 symtab_hdr
->sh_info
,
4090 0, NULL
, NULL
, NULL
)))
4093 /* Get the value of the symbol referred to by the reloc. */
4094 if (ELFNN_R_SYM (rel
->r_info
) < symtab_hdr
->sh_info
)
4096 /* A local symbol. */
4097 Elf_Internal_Sym
*isym
= ((Elf_Internal_Sym
*) symtab_hdr
->contents
4098 + ELFNN_R_SYM (rel
->r_info
));
4099 reserve_size
= (isym
->st_size
- rel
->r_addend
) > isym
->st_size
4100 ? 0 : isym
->st_size
- rel
->r_addend
;
4102 if (isym
->st_shndx
== SHN_UNDEF
)
4103 sym_sec
= sec
, symval
= rel
->r_offset
;
4106 BFD_ASSERT (isym
->st_shndx
< elf_numsections (abfd
));
4107 sym_sec
= elf_elfsections (abfd
)[isym
->st_shndx
]->bfd_section
;
4109 /* The purpose of this code is unknown. It breaks linker scripts
4110 for embedded development that place sections at address zero.
4111 This code is believed to be unnecessary. Disabling it but not
4112 yet removing it, in case something breaks. */
4113 if (sec_addr (sym_sec
) == 0)
4116 symval
= isym
->st_value
;
4118 symtype
= ELF_ST_TYPE (isym
->st_info
);
4123 struct elf_link_hash_entry
*h
;
4125 indx
= ELFNN_R_SYM (rel
->r_info
) - symtab_hdr
->sh_info
;
4126 h
= elf_sym_hashes (abfd
)[indx
];
4128 while (h
->root
.type
== bfd_link_hash_indirect
4129 || h
->root
.type
== bfd_link_hash_warning
)
4130 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
4132 if (h
->root
.type
== bfd_link_hash_undefweak
4133 && (relax_func
== _bfd_riscv_relax_lui
4134 || relax_func
== _bfd_riscv_relax_pc
))
4136 /* For the lui and auipc relaxations, since the symbol
4137 value of an undefined weak symbol is always be zero,
4138 we can optimize the patterns into a single LI/MV/ADDI
4141 Note that, creating shared libraries and pie output may
4142 break the rule above. Fortunately, since we do not relax
4143 pc relocs when creating shared libraries and pie output,
4144 and the absolute address access for R_RISCV_HI20 isn't
4145 allowed when "-fPIC" is set, the problem of creating shared
4146 libraries can not happen currently. Once we support the
4147 auipc relaxations when creating shared libraries, then we will
4148 need the more rigorous checking for this optimization. */
4149 undefined_weak
= TRUE
;
4152 /* This line has to match the check in riscv_elf_relocate_section
4153 in the R_RISCV_CALL[_PLT] case. */
4154 if (bfd_link_pic (info
) && h
->plt
.offset
!= MINUS_ONE
)
4156 sym_sec
= htab
->elf
.splt
;
4157 symval
= h
->plt
.offset
;
4159 else if (undefined_weak
)
4162 sym_sec
= bfd_und_section_ptr
;
4164 else if (h
->root
.u
.def
.section
->output_section
== NULL
4165 || (h
->root
.type
!= bfd_link_hash_defined
4166 && h
->root
.type
!= bfd_link_hash_defweak
))
4170 symval
= h
->root
.u
.def
.value
;
4171 sym_sec
= h
->root
.u
.def
.section
;
4174 if (h
->type
!= STT_FUNC
)
4176 (h
->size
- rel
->r_addend
) > h
->size
? 0 : h
->size
- rel
->r_addend
;
4180 if (sym_sec
->sec_info_type
== SEC_INFO_TYPE_MERGE
4181 && (sym_sec
->flags
& SEC_MERGE
))
4183 /* At this stage in linking, no SEC_MERGE symbol has been
4184 adjusted, so all references to such symbols need to be
4185 passed through _bfd_merged_section_offset. (Later, in
4186 relocate_section, all SEC_MERGE symbols *except* for
4187 section symbols have been adjusted.)
4189 gas may reduce relocations against symbols in SEC_MERGE
4190 sections to a relocation against the section symbol when
4191 the original addend was zero. When the reloc is against
4192 a section symbol we should include the addend in the
4193 offset passed to _bfd_merged_section_offset, since the
4194 location of interest is the original symbol. On the
4195 other hand, an access to "sym+addend" where "sym" is not
4196 a section symbol should not include the addend; Such an
4197 access is presumed to be an offset from "sym"; The
4198 location of interest is just "sym". */
4199 if (symtype
== STT_SECTION
)
4200 symval
+= rel
->r_addend
;
4202 symval
= _bfd_merged_section_offset (abfd
, &sym_sec
,
4203 elf_section_data (sym_sec
)->sec_info
,
4206 if (symtype
!= STT_SECTION
)
4207 symval
+= rel
->r_addend
;
4210 symval
+= rel
->r_addend
;
4212 symval
+= sec_addr (sym_sec
);
4214 if (!relax_func (abfd
, sec
, sym_sec
, info
, rel
, symval
,
4215 max_alignment
, reserve_size
, again
,
4216 &pcgp_relocs
, undefined_weak
))
4223 if (relocs
!= data
->relocs
)
4225 riscv_free_pcgp_relocs(&pcgp_relocs
, abfd
, sec
);
4231 # define PRSTATUS_SIZE 204
4232 # define PRSTATUS_OFFSET_PR_CURSIG 12
4233 # define PRSTATUS_OFFSET_PR_PID 24
4234 # define PRSTATUS_OFFSET_PR_REG 72
4235 # define ELF_GREGSET_T_SIZE 128
4236 # define PRPSINFO_SIZE 128
4237 # define PRPSINFO_OFFSET_PR_PID 16
4238 # define PRPSINFO_OFFSET_PR_FNAME 32
4239 # define PRPSINFO_OFFSET_PR_PSARGS 48
4241 # define PRSTATUS_SIZE 376
4242 # define PRSTATUS_OFFSET_PR_CURSIG 12
4243 # define PRSTATUS_OFFSET_PR_PID 32
4244 # define PRSTATUS_OFFSET_PR_REG 112
4245 # define ELF_GREGSET_T_SIZE 256
4246 # define PRPSINFO_SIZE 136
4247 # define PRPSINFO_OFFSET_PR_PID 24
4248 # define PRPSINFO_OFFSET_PR_FNAME 40
4249 # define PRPSINFO_OFFSET_PR_PSARGS 56
4252 /* Support for core dump NOTE sections. */
4255 riscv_elf_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
4257 switch (note
->descsz
)
4262 case PRSTATUS_SIZE
: /* sizeof(struct elf_prstatus) on Linux/RISC-V. */
4264 elf_tdata (abfd
)->core
->signal
4265 = bfd_get_16 (abfd
, note
->descdata
+ PRSTATUS_OFFSET_PR_CURSIG
);
4268 elf_tdata (abfd
)->core
->lwpid
4269 = bfd_get_32 (abfd
, note
->descdata
+ PRSTATUS_OFFSET_PR_PID
);
4273 /* Make a ".reg/999" section. */
4274 return _bfd_elfcore_make_pseudosection (abfd
, ".reg", ELF_GREGSET_T_SIZE
,
4275 note
->descpos
+ PRSTATUS_OFFSET_PR_REG
);
4279 riscv_elf_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
4281 switch (note
->descsz
)
4286 case PRPSINFO_SIZE
: /* sizeof(struct elf_prpsinfo) on Linux/RISC-V. */
4288 elf_tdata (abfd
)->core
->pid
4289 = bfd_get_32 (abfd
, note
->descdata
+ PRPSINFO_OFFSET_PR_PID
);
4292 elf_tdata (abfd
)->core
->program
= _bfd_elfcore_strndup
4293 (abfd
, note
->descdata
+ PRPSINFO_OFFSET_PR_FNAME
, 16);
4296 elf_tdata (abfd
)->core
->command
= _bfd_elfcore_strndup
4297 (abfd
, note
->descdata
+ PRPSINFO_OFFSET_PR_PSARGS
, 80);
4301 /* Note that for some reason, a spurious space is tacked
4302 onto the end of the args in some (at least one anyway)
4303 implementations, so strip it off if it exists. */
4306 char *command
= elf_tdata (abfd
)->core
->command
;
4307 int n
= strlen (command
);
4309 if (0 < n
&& command
[n
- 1] == ' ')
4310 command
[n
- 1] = '\0';
4316 /* Set the right mach type. */
4318 riscv_elf_object_p (bfd
*abfd
)
4320 /* There are only two mach types in RISCV currently. */
4321 if (strcmp (abfd
->xvec
->name
, "elf32-littleriscv") == 0)
4322 bfd_default_set_arch_mach (abfd
, bfd_arch_riscv
, bfd_mach_riscv32
);
4324 bfd_default_set_arch_mach (abfd
, bfd_arch_riscv
, bfd_mach_riscv64
);
4329 /* Determine whether an object attribute tag takes an integer, a
4333 riscv_elf_obj_attrs_arg_type (int tag
)
4335 return (tag
& 1) != 0 ? ATTR_TYPE_FLAG_STR_VAL
: ATTR_TYPE_FLAG_INT_VAL
;
4338 #define TARGET_LITTLE_SYM riscv_elfNN_vec
4339 #define TARGET_LITTLE_NAME "elfNN-littleriscv"
4341 #define elf_backend_reloc_type_class riscv_reloc_type_class
4343 #define bfd_elfNN_bfd_reloc_name_lookup riscv_reloc_name_lookup
4344 #define bfd_elfNN_bfd_link_hash_table_create riscv_elf_link_hash_table_create
4345 #define bfd_elfNN_bfd_reloc_type_lookup riscv_reloc_type_lookup
4346 #define bfd_elfNN_bfd_merge_private_bfd_data \
4347 _bfd_riscv_elf_merge_private_bfd_data
4349 #define elf_backend_copy_indirect_symbol riscv_elf_copy_indirect_symbol
4350 #define elf_backend_create_dynamic_sections riscv_elf_create_dynamic_sections
4351 #define elf_backend_check_relocs riscv_elf_check_relocs
4352 #define elf_backend_adjust_dynamic_symbol riscv_elf_adjust_dynamic_symbol
4353 #define elf_backend_size_dynamic_sections riscv_elf_size_dynamic_sections
4354 #define elf_backend_relocate_section riscv_elf_relocate_section
4355 #define elf_backend_finish_dynamic_symbol riscv_elf_finish_dynamic_symbol
4356 #define elf_backend_finish_dynamic_sections riscv_elf_finish_dynamic_sections
4357 #define elf_backend_gc_mark_hook riscv_elf_gc_mark_hook
4358 #define elf_backend_plt_sym_val riscv_elf_plt_sym_val
4359 #define elf_backend_grok_prstatus riscv_elf_grok_prstatus
4360 #define elf_backend_grok_psinfo riscv_elf_grok_psinfo
4361 #define elf_backend_object_p riscv_elf_object_p
4362 #define elf_info_to_howto_rel NULL
4363 #define elf_info_to_howto riscv_info_to_howto_rela
4364 #define bfd_elfNN_bfd_relax_section _bfd_riscv_relax_section
4366 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
4368 #define elf_backend_can_gc_sections 1
4369 #define elf_backend_can_refcount 1
4370 #define elf_backend_want_got_plt 1
4371 #define elf_backend_plt_readonly 1
4372 #define elf_backend_plt_alignment 4
4373 #define elf_backend_want_plt_sym 1
4374 #define elf_backend_got_header_size (ARCH_SIZE / 8)
4375 #define elf_backend_want_dynrelro 1
4376 #define elf_backend_rela_normal 1
4377 #define elf_backend_default_execstack 0
4379 #undef elf_backend_obj_attrs_vendor
4380 #define elf_backend_obj_attrs_vendor "riscv"
4381 #undef elf_backend_obj_attrs_arg_type
4382 #define elf_backend_obj_attrs_arg_type riscv_elf_obj_attrs_arg_type
4383 #undef elf_backend_obj_attrs_section_type
4384 #define elf_backend_obj_attrs_section_type SHT_RISCV_ATTRIBUTES
4385 #undef elf_backend_obj_attrs_section
4386 #define elf_backend_obj_attrs_section ".riscv.attributes"
4388 #include "elfNN-target.h"