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
;
72 #define riscv_elf_hash_entry(ent) \
73 ((struct riscv_elf_link_hash_entry *)(ent))
75 struct _bfd_riscv_elf_obj_tdata
77 struct elf_obj_tdata root
;
79 /* tls_type for each local got entry. */
80 char *local_got_tls_type
;
83 #define _bfd_riscv_elf_tdata(abfd) \
84 ((struct _bfd_riscv_elf_obj_tdata *) (abfd)->tdata.any)
86 #define _bfd_riscv_elf_local_got_tls_type(abfd) \
87 (_bfd_riscv_elf_tdata (abfd)->local_got_tls_type)
89 #define _bfd_riscv_elf_tls_type(abfd, h, symndx) \
90 (*((h) != NULL ? &riscv_elf_hash_entry (h)->tls_type \
91 : &_bfd_riscv_elf_local_got_tls_type (abfd) [symndx]))
93 #define is_riscv_elf(bfd) \
94 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
95 && elf_tdata (bfd) != NULL \
96 && elf_object_id (bfd) == RISCV_ELF_DATA)
99 elfNN_riscv_mkobject (bfd
*abfd
)
101 return bfd_elf_allocate_object (abfd
,
102 sizeof (struct _bfd_riscv_elf_obj_tdata
),
106 #include "elf/common.h"
107 #include "elf/internal.h"
109 struct riscv_elf_link_hash_table
111 struct elf_link_hash_table elf
;
113 /* Short-cuts to get to dynamic linker sections. */
116 /* Small local sym to section mapping cache. */
117 struct sym_cache sym_cache
;
119 /* The max alignment of output sections. */
120 bfd_vma max_alignment
;
124 /* Get the RISC-V ELF linker hash table from a link_info structure. */
125 #define riscv_elf_hash_table(p) \
126 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
127 == RISCV_ELF_DATA ? ((struct riscv_elf_link_hash_table *) ((p)->hash)) : NULL)
130 riscv_info_to_howto_rela (bfd
*abfd
,
132 Elf_Internal_Rela
*dst
)
134 cache_ptr
->howto
= riscv_elf_rtype_to_howto (abfd
, ELFNN_R_TYPE (dst
->r_info
));
135 return cache_ptr
->howto
!= NULL
;
139 riscv_elf_append_rela (bfd
*abfd
, asection
*s
, Elf_Internal_Rela
*rel
)
141 const struct elf_backend_data
*bed
;
144 bed
= get_elf_backend_data (abfd
);
145 loc
= s
->contents
+ (s
->reloc_count
++ * bed
->s
->sizeof_rela
);
146 bed
->s
->swap_reloca_out (abfd
, rel
, loc
);
151 #define PLT_HEADER_INSNS 8
152 #define PLT_ENTRY_INSNS 4
153 #define PLT_HEADER_SIZE (PLT_HEADER_INSNS * 4)
154 #define PLT_ENTRY_SIZE (PLT_ENTRY_INSNS * 4)
156 #define GOT_ENTRY_SIZE RISCV_ELF_WORD_BYTES
158 #define GOTPLT_HEADER_SIZE (2 * GOT_ENTRY_SIZE)
160 #define sec_addr(sec) ((sec)->output_section->vma + (sec)->output_offset)
163 riscv_elf_got_plt_val (bfd_vma plt_index
, struct bfd_link_info
*info
)
165 return sec_addr (riscv_elf_hash_table (info
)->elf
.sgotplt
)
166 + GOTPLT_HEADER_SIZE
+ (plt_index
* GOT_ENTRY_SIZE
);
170 # define MATCH_LREG MATCH_LW
172 # define MATCH_LREG MATCH_LD
175 /* Generate a PLT header. */
178 riscv_make_plt_header (bfd
*output_bfd
, bfd_vma gotplt_addr
, bfd_vma addr
,
181 bfd_vma gotplt_offset_high
= RISCV_PCREL_HIGH_PART (gotplt_addr
, addr
);
182 bfd_vma gotplt_offset_low
= RISCV_PCREL_LOW_PART (gotplt_addr
, addr
);
184 /* RVE has no t3 register, so this won't work, and is not supported. */
185 if (elf_elfheader (output_bfd
)->e_flags
& EF_RISCV_RVE
)
187 _bfd_error_handler (_("%pB: warning: RVE PLT generation not supported"),
192 /* auipc t2, %hi(.got.plt)
193 sub t1, t1, t3 # shifted .got.plt offset + hdr size + 12
194 l[w|d] t3, %lo(.got.plt)(t2) # _dl_runtime_resolve
195 addi t1, t1, -(hdr size + 12) # shifted .got.plt offset
196 addi t0, t2, %lo(.got.plt) # &.got.plt
197 srli t1, t1, log2(16/PTRSIZE) # .got.plt offset
198 l[w|d] t0, PTRSIZE(t0) # link map
201 entry
[0] = RISCV_UTYPE (AUIPC
, X_T2
, gotplt_offset_high
);
202 entry
[1] = RISCV_RTYPE (SUB
, X_T1
, X_T1
, X_T3
);
203 entry
[2] = RISCV_ITYPE (LREG
, X_T3
, X_T2
, gotplt_offset_low
);
204 entry
[3] = RISCV_ITYPE (ADDI
, X_T1
, X_T1
, -(PLT_HEADER_SIZE
+ 12));
205 entry
[4] = RISCV_ITYPE (ADDI
, X_T0
, X_T2
, gotplt_offset_low
);
206 entry
[5] = RISCV_ITYPE (SRLI
, X_T1
, X_T1
, 4 - RISCV_ELF_LOG_WORD_BYTES
);
207 entry
[6] = RISCV_ITYPE (LREG
, X_T0
, X_T0
, RISCV_ELF_WORD_BYTES
);
208 entry
[7] = RISCV_ITYPE (JALR
, 0, X_T3
, 0);
213 /* Generate a PLT entry. */
216 riscv_make_plt_entry (bfd
*output_bfd
, bfd_vma got
, bfd_vma addr
,
219 /* RVE has no t3 register, so this won't work, and is not supported. */
220 if (elf_elfheader (output_bfd
)->e_flags
& EF_RISCV_RVE
)
222 _bfd_error_handler (_("%pB: warning: RVE PLT generation not supported"),
227 /* auipc t3, %hi(.got.plt entry)
228 l[w|d] t3, %lo(.got.plt entry)(t3)
232 entry
[0] = RISCV_UTYPE (AUIPC
, X_T3
, RISCV_PCREL_HIGH_PART (got
, addr
));
233 entry
[1] = RISCV_ITYPE (LREG
, X_T3
, X_T3
, RISCV_PCREL_LOW_PART (got
, addr
));
234 entry
[2] = RISCV_ITYPE (JALR
, X_T1
, X_T3
, 0);
235 entry
[3] = RISCV_NOP
;
240 /* Create an entry in an RISC-V ELF linker hash table. */
242 static struct bfd_hash_entry
*
243 link_hash_newfunc (struct bfd_hash_entry
*entry
,
244 struct bfd_hash_table
*table
, const char *string
)
246 /* Allocate the structure if it has not already been allocated by a
251 bfd_hash_allocate (table
,
252 sizeof (struct riscv_elf_link_hash_entry
));
257 /* Call the allocation method of the superclass. */
258 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
261 struct riscv_elf_link_hash_entry
*eh
;
263 eh
= (struct riscv_elf_link_hash_entry
*) entry
;
264 eh
->tls_type
= GOT_UNKNOWN
;
270 /* Create a RISC-V ELF linker hash table. */
272 static struct bfd_link_hash_table
*
273 riscv_elf_link_hash_table_create (bfd
*abfd
)
275 struct riscv_elf_link_hash_table
*ret
;
276 size_t amt
= sizeof (struct riscv_elf_link_hash_table
);
278 ret
= (struct riscv_elf_link_hash_table
*) bfd_zmalloc (amt
);
282 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
, link_hash_newfunc
,
283 sizeof (struct riscv_elf_link_hash_entry
),
290 ret
->max_alignment
= (bfd_vma
) -1;
291 return &ret
->elf
.root
;
294 /* Create the .got section. */
297 riscv_elf_create_got_section (bfd
*abfd
, struct bfd_link_info
*info
)
301 struct elf_link_hash_entry
*h
;
302 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
303 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
305 /* This function may be called more than once. */
306 if (htab
->sgot
!= NULL
)
309 flags
= bed
->dynamic_sec_flags
;
311 s
= bfd_make_section_anyway_with_flags (abfd
,
312 (bed
->rela_plts_and_copies_p
313 ? ".rela.got" : ".rel.got"),
314 (bed
->dynamic_sec_flags
317 || !bfd_set_section_alignment (s
, bed
->s
->log_file_align
))
321 s
= s_got
= bfd_make_section_anyway_with_flags (abfd
, ".got", flags
);
323 || !bfd_set_section_alignment (s
, bed
->s
->log_file_align
))
327 /* The first bit of the global offset table is the header. */
328 s
->size
+= bed
->got_header_size
;
330 if (bed
->want_got_plt
)
332 s
= bfd_make_section_anyway_with_flags (abfd
, ".got.plt", flags
);
334 || !bfd_set_section_alignment (s
, bed
->s
->log_file_align
))
338 /* Reserve room for the header. */
339 s
->size
+= GOTPLT_HEADER_SIZE
;
342 if (bed
->want_got_sym
)
344 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
345 section. We don't do this in the linker script because we don't want
346 to define the symbol if we are not creating a global offset
348 h
= _bfd_elf_define_linkage_sym (abfd
, info
, s_got
,
349 "_GLOBAL_OFFSET_TABLE_");
350 elf_hash_table (info
)->hgot
= h
;
358 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
359 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
363 riscv_elf_create_dynamic_sections (bfd
*dynobj
,
364 struct bfd_link_info
*info
)
366 struct riscv_elf_link_hash_table
*htab
;
368 htab
= riscv_elf_hash_table (info
);
369 BFD_ASSERT (htab
!= NULL
);
371 if (!riscv_elf_create_got_section (dynobj
, info
))
374 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
377 if (!bfd_link_pic (info
))
379 /* Technically, this section doesn't have contents. It is used as the
380 target of TLS copy relocs, to copy TLS data from shared libraries into
381 the executable. However, if we don't mark it as loadable, then it
382 matches the IS_TBSS test in ldlang.c, and there is no run-time address
383 space allocated for it even though it has SEC_ALLOC. That test is
384 correct for .tbss, but not correct for this section. There is also
385 a second problem that having a section with no contents can only work
386 if it comes after all sections with contents in the same segment,
387 but the linker script does not guarantee that. This is just mixed in
388 with other .tdata.* sections. We can fix both problems by lying and
389 saying that there are contents. This section is expected to be small
390 so this should not cause a significant extra program startup cost. */
392 bfd_make_section_anyway_with_flags (dynobj
, ".tdata.dyn",
393 (SEC_ALLOC
| SEC_THREAD_LOCAL
394 | SEC_LOAD
| SEC_DATA
396 | SEC_LINKER_CREATED
));
399 if (!htab
->elf
.splt
|| !htab
->elf
.srelplt
|| !htab
->elf
.sdynbss
400 || (!bfd_link_pic (info
) && (!htab
->elf
.srelbss
|| !htab
->sdyntdata
)))
406 /* Copy the extra info we tack onto an elf_link_hash_entry. */
409 riscv_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
410 struct elf_link_hash_entry
*dir
,
411 struct elf_link_hash_entry
*ind
)
413 struct riscv_elf_link_hash_entry
*edir
, *eind
;
415 edir
= (struct riscv_elf_link_hash_entry
*) dir
;
416 eind
= (struct riscv_elf_link_hash_entry
*) ind
;
418 if (ind
->root
.type
== bfd_link_hash_indirect
419 && dir
->got
.refcount
<= 0)
421 edir
->tls_type
= eind
->tls_type
;
422 eind
->tls_type
= GOT_UNKNOWN
;
424 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
428 riscv_elf_record_tls_type (bfd
*abfd
, struct elf_link_hash_entry
*h
,
429 unsigned long symndx
, char tls_type
)
431 char *new_tls_type
= &_bfd_riscv_elf_tls_type (abfd
, h
, symndx
);
433 *new_tls_type
|= tls_type
;
434 if ((*new_tls_type
& GOT_NORMAL
) && (*new_tls_type
& ~GOT_NORMAL
))
436 (*_bfd_error_handler
)
437 (_("%pB: `%s' accessed both as normal and thread local symbol"),
438 abfd
, h
? h
->root
.root
.string
: "<local>");
445 riscv_elf_record_got_reference (bfd
*abfd
, struct bfd_link_info
*info
,
446 struct elf_link_hash_entry
*h
, long symndx
)
448 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
449 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
451 if (htab
->elf
.sgot
== NULL
)
453 if (!riscv_elf_create_got_section (htab
->elf
.dynobj
, info
))
459 h
->got
.refcount
+= 1;
463 /* This is a global offset table entry for a local symbol. */
464 if (elf_local_got_refcounts (abfd
) == NULL
)
466 bfd_size_type size
= symtab_hdr
->sh_info
* (sizeof (bfd_vma
) + 1);
467 if (!(elf_local_got_refcounts (abfd
) = bfd_zalloc (abfd
, size
)))
469 _bfd_riscv_elf_local_got_tls_type (abfd
)
470 = (char *) (elf_local_got_refcounts (abfd
) + symtab_hdr
->sh_info
);
472 elf_local_got_refcounts (abfd
) [symndx
] += 1;
478 bad_static_reloc (bfd
*abfd
, unsigned r_type
, struct elf_link_hash_entry
*h
)
480 reloc_howto_type
* r
= riscv_elf_rtype_to_howto (abfd
, r_type
);
482 (*_bfd_error_handler
)
483 (_("%pB: relocation %s against `%s' can not be used when making a shared "
484 "object; recompile with -fPIC"),
485 abfd
, r
? r
->name
: _("<unknown>"),
486 h
!= NULL
? h
->root
.root
.string
: "a local symbol");
487 bfd_set_error (bfd_error_bad_value
);
490 /* Look through the relocs for a section during the first phase, and
491 allocate space in the global offset table or procedure linkage
495 riscv_elf_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
496 asection
*sec
, const Elf_Internal_Rela
*relocs
)
498 struct riscv_elf_link_hash_table
*htab
;
499 Elf_Internal_Shdr
*symtab_hdr
;
500 struct elf_link_hash_entry
**sym_hashes
;
501 const Elf_Internal_Rela
*rel
;
502 asection
*sreloc
= NULL
;
504 if (bfd_link_relocatable (info
))
507 htab
= riscv_elf_hash_table (info
);
508 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
509 sym_hashes
= elf_sym_hashes (abfd
);
511 if (htab
->elf
.dynobj
== NULL
)
512 htab
->elf
.dynobj
= abfd
;
514 for (rel
= relocs
; rel
< relocs
+ sec
->reloc_count
; rel
++)
517 unsigned int r_symndx
;
518 struct elf_link_hash_entry
*h
;
520 r_symndx
= ELFNN_R_SYM (rel
->r_info
);
521 r_type
= ELFNN_R_TYPE (rel
->r_info
);
523 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
525 (*_bfd_error_handler
) (_("%pB: bad symbol index: %d"),
530 if (r_symndx
< symtab_hdr
->sh_info
)
534 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
535 while (h
->root
.type
== bfd_link_hash_indirect
536 || h
->root
.type
== bfd_link_hash_warning
)
537 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
542 case R_RISCV_TLS_GD_HI20
:
543 if (!riscv_elf_record_got_reference (abfd
, info
, h
, r_symndx
)
544 || !riscv_elf_record_tls_type (abfd
, h
, r_symndx
, GOT_TLS_GD
))
548 case R_RISCV_TLS_GOT_HI20
:
549 if (bfd_link_pic (info
))
550 info
->flags
|= DF_STATIC_TLS
;
551 if (!riscv_elf_record_got_reference (abfd
, info
, h
, r_symndx
)
552 || !riscv_elf_record_tls_type (abfd
, h
, r_symndx
, GOT_TLS_IE
))
556 case R_RISCV_GOT_HI20
:
557 if (!riscv_elf_record_got_reference (abfd
, info
, h
, r_symndx
)
558 || !riscv_elf_record_tls_type (abfd
, h
, r_symndx
, GOT_NORMAL
))
562 case R_RISCV_CALL_PLT
:
563 /* This symbol requires a procedure linkage table entry. We
564 actually build the entry in adjust_dynamic_symbol,
565 because this might be a case of linking PIC code without
566 linking in any dynamic objects, in which case we don't
567 need to generate a procedure linkage table after all. */
572 h
->plt
.refcount
+= 1;
579 case R_RISCV_RVC_BRANCH
:
580 case R_RISCV_RVC_JUMP
:
581 case R_RISCV_PCREL_HI20
:
582 /* In shared libraries, these relocs are known to bind locally. */
583 if (bfd_link_pic (info
))
587 case R_RISCV_TPREL_HI20
:
588 if (!bfd_link_executable (info
))
589 return bad_static_reloc (abfd
, r_type
, h
);
591 riscv_elf_record_tls_type (abfd
, h
, r_symndx
, GOT_TLS_LE
);
595 if (bfd_link_pic (info
))
596 return bad_static_reloc (abfd
, r_type
, h
);
600 case R_RISCV_JUMP_SLOT
:
601 case R_RISCV_RELATIVE
:
607 /* This reloc might not bind locally. */
611 if (h
!= NULL
&& !bfd_link_pic (info
))
613 /* We may need a .plt entry if the function this reloc
614 refers to is in a shared lib. */
615 h
->plt
.refcount
+= 1;
618 /* If we are creating a shared library, and this is a reloc
619 against a global symbol, or a non PC relative reloc
620 against a local symbol, then we need to copy the reloc
621 into the shared library. However, if we are linking with
622 -Bsymbolic, we do not need to copy a reloc against a
623 global symbol which is defined in an object we are
624 including in the link (i.e., DEF_REGULAR is set). At
625 this point we have not seen all the input files, so it is
626 possible that DEF_REGULAR is not set now but will be set
627 later (it is never cleared). In case of a weak definition,
628 DEF_REGULAR may be cleared later by a strong definition in
629 a shared library. We account for that possibility below by
630 storing information in the relocs_copied field of the hash
631 table entry. A similar situation occurs when creating
632 shared libraries and symbol visibility changes render the
635 If on the other hand, we are creating an executable, we
636 may need to keep relocations for symbols satisfied by a
637 dynamic library if we manage to avoid copy relocs for the
639 reloc_howto_type
* r
= riscv_elf_rtype_to_howto (abfd
, r_type
);
641 if ((bfd_link_pic (info
)
642 && (sec
->flags
& SEC_ALLOC
) != 0
643 && ((r
!= NULL
&& ! r
->pc_relative
)
646 || h
->root
.type
== bfd_link_hash_defweak
647 || !h
->def_regular
))))
648 || (!bfd_link_pic (info
)
649 && (sec
->flags
& SEC_ALLOC
) != 0
651 && (h
->root
.type
== bfd_link_hash_defweak
652 || !h
->def_regular
)))
654 struct elf_dyn_relocs
*p
;
655 struct elf_dyn_relocs
**head
;
657 /* When creating a shared object, we must copy these
658 relocs into the output file. We create a reloc
659 section in dynobj and make room for the reloc. */
662 sreloc
= _bfd_elf_make_dynamic_reloc_section
663 (sec
, htab
->elf
.dynobj
, RISCV_ELF_LOG_WORD_BYTES
,
664 abfd
, /*rela?*/ TRUE
);
670 /* If this is a global symbol, we count the number of
671 relocations we need for this symbol. */
673 head
= &h
->dyn_relocs
;
676 /* Track dynamic relocs needed for local syms too.
677 We really need local syms available to do this
682 Elf_Internal_Sym
*isym
;
684 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
689 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
693 vpp
= &elf_section_data (s
)->local_dynrel
;
694 head
= (struct elf_dyn_relocs
**) vpp
;
698 if (p
== NULL
|| p
->sec
!= sec
)
700 size_t amt
= sizeof *p
;
701 p
= ((struct elf_dyn_relocs
*)
702 bfd_alloc (htab
->elf
.dynobj
, amt
));
713 p
->pc_count
+= r
== NULL
? 0 : r
->pc_relative
;
718 case R_RISCV_GNU_VTINHERIT
:
719 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
723 case R_RISCV_GNU_VTENTRY
:
724 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
737 riscv_elf_gc_mark_hook (asection
*sec
,
738 struct bfd_link_info
*info
,
739 Elf_Internal_Rela
*rel
,
740 struct elf_link_hash_entry
*h
,
741 Elf_Internal_Sym
*sym
)
744 switch (ELFNN_R_TYPE (rel
->r_info
))
746 case R_RISCV_GNU_VTINHERIT
:
747 case R_RISCV_GNU_VTENTRY
:
751 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
754 /* Adjust a symbol defined by a dynamic object and referenced by a
755 regular object. The current definition is in some section of the
756 dynamic object, but we're not including those sections. We have to
757 change the definition to something the rest of the link can
761 riscv_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
762 struct elf_link_hash_entry
*h
)
764 struct riscv_elf_link_hash_table
*htab
;
765 struct riscv_elf_link_hash_entry
* eh
;
769 htab
= riscv_elf_hash_table (info
);
770 BFD_ASSERT (htab
!= NULL
);
772 dynobj
= htab
->elf
.dynobj
;
774 /* Make sure we know what is going on here. */
775 BFD_ASSERT (dynobj
!= NULL
777 || h
->type
== STT_GNU_IFUNC
781 && !h
->def_regular
)));
783 /* If this is a function, put it in the procedure linkage table. We
784 will fill in the contents of the procedure linkage table later
785 (although we could actually do it here). */
786 if (h
->type
== STT_FUNC
|| h
->type
== STT_GNU_IFUNC
|| h
->needs_plt
)
788 if (h
->plt
.refcount
<= 0
789 || SYMBOL_CALLS_LOCAL (info
, h
)
790 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
791 && h
->root
.type
== bfd_link_hash_undefweak
))
793 /* This case can occur if we saw a R_RISCV_CALL_PLT reloc in an
794 input file, but the symbol was never referred to by a dynamic
795 object, or if all references were garbage collected. In such
796 a case, we don't actually need to build a PLT entry. */
797 h
->plt
.offset
= (bfd_vma
) -1;
804 h
->plt
.offset
= (bfd_vma
) -1;
806 /* If this is a weak symbol, and there is a real definition, the
807 processor independent code will have arranged for us to see the
808 real definition first, and we can just use the same value. */
811 struct elf_link_hash_entry
*def
= weakdef (h
);
812 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
813 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
814 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
818 /* This is a reference to a symbol defined by a dynamic object which
819 is not a function. */
821 /* If we are creating a shared library, we must presume that the
822 only references to the symbol are via the global offset table.
823 For such cases we need not do anything here; the relocations will
824 be handled correctly by relocate_section. */
825 if (bfd_link_pic (info
))
828 /* If there are no references to this symbol that do not use the
829 GOT, we don't need to generate a copy reloc. */
833 /* If -z nocopyreloc was given, we won't generate them either. */
834 if (info
->nocopyreloc
)
840 /* If we don't find any dynamic relocs in read-only sections, then
841 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
842 if (!_bfd_elf_readonly_dynrelocs (h
))
848 /* We must allocate the symbol in our .dynbss section, which will
849 become part of the .bss section of the executable. There will be
850 an entry for this symbol in the .dynsym section. The dynamic
851 object will contain position independent code, so all references
852 from the dynamic object to this symbol will go through the global
853 offset table. The dynamic linker will use the .dynsym entry to
854 determine the address it must put in the global offset table, so
855 both the dynamic object and the regular object will refer to the
856 same memory location for the variable. */
858 /* We must generate a R_RISCV_COPY reloc to tell the dynamic linker
859 to copy the initial value out of the dynamic object and into the
860 runtime process image. We need to remember the offset into the
861 .rel.bss section we are going to use. */
862 eh
= (struct riscv_elf_link_hash_entry
*) h
;
863 if (eh
->tls_type
& ~GOT_NORMAL
)
866 srel
= htab
->elf
.srelbss
;
868 else if ((h
->root
.u
.def
.section
->flags
& SEC_READONLY
) != 0)
870 s
= htab
->elf
.sdynrelro
;
871 srel
= htab
->elf
.sreldynrelro
;
875 s
= htab
->elf
.sdynbss
;
876 srel
= htab
->elf
.srelbss
;
878 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
880 srel
->size
+= sizeof (ElfNN_External_Rela
);
884 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
887 /* Allocate space in .plt, .got and associated reloc sections for
891 allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
893 struct bfd_link_info
*info
;
894 struct riscv_elf_link_hash_table
*htab
;
895 struct elf_dyn_relocs
*p
;
897 if (h
->root
.type
== bfd_link_hash_indirect
)
900 info
= (struct bfd_link_info
*) inf
;
901 htab
= riscv_elf_hash_table (info
);
902 BFD_ASSERT (htab
!= NULL
);
904 if (htab
->elf
.dynamic_sections_created
905 && h
->plt
.refcount
> 0)
907 /* Make sure this symbol is output as a dynamic symbol.
908 Undefined weak syms won't yet be marked as dynamic. */
912 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
916 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info
), h
))
918 asection
*s
= htab
->elf
.splt
;
921 s
->size
= PLT_HEADER_SIZE
;
923 h
->plt
.offset
= s
->size
;
925 /* Make room for this entry. */
926 s
->size
+= PLT_ENTRY_SIZE
;
928 /* We also need to make an entry in the .got.plt section. */
929 htab
->elf
.sgotplt
->size
+= GOT_ENTRY_SIZE
;
931 /* We also need to make an entry in the .rela.plt section. */
932 htab
->elf
.srelplt
->size
+= sizeof (ElfNN_External_Rela
);
934 /* If this symbol is not defined in a regular file, and we are
935 not generating a shared library, then set the symbol to this
936 location in the .plt. This is required to make function
937 pointers compare as equal between the normal executable and
938 the shared library. */
939 if (! bfd_link_pic (info
)
942 h
->root
.u
.def
.section
= s
;
943 h
->root
.u
.def
.value
= h
->plt
.offset
;
948 h
->plt
.offset
= (bfd_vma
) -1;
954 h
->plt
.offset
= (bfd_vma
) -1;
958 if (h
->got
.refcount
> 0)
962 int tls_type
= riscv_elf_hash_entry (h
)->tls_type
;
964 /* Make sure this symbol is output as a dynamic symbol.
965 Undefined weak syms won't yet be marked as dynamic. */
969 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
974 h
->got
.offset
= s
->size
;
975 dyn
= htab
->elf
.dynamic_sections_created
;
976 if (tls_type
& (GOT_TLS_GD
| GOT_TLS_IE
))
978 /* TLS_GD needs two dynamic relocs and two GOT slots. */
979 if (tls_type
& GOT_TLS_GD
)
981 s
->size
+= 2 * RISCV_ELF_WORD_BYTES
;
982 htab
->elf
.srelgot
->size
+= 2 * sizeof (ElfNN_External_Rela
);
985 /* TLS_IE needs one dynamic reloc and one GOT slot. */
986 if (tls_type
& GOT_TLS_IE
)
988 s
->size
+= RISCV_ELF_WORD_BYTES
;
989 htab
->elf
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
994 s
->size
+= RISCV_ELF_WORD_BYTES
;
995 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, bfd_link_pic (info
), h
)
996 && ! UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
997 htab
->elf
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
1001 h
->got
.offset
= (bfd_vma
) -1;
1003 if (h
->dyn_relocs
== NULL
)
1006 /* In the shared -Bsymbolic case, discard space allocated for
1007 dynamic pc-relative relocs against symbols which turn out to be
1008 defined in regular objects. For the normal shared case, discard
1009 space for pc-relative relocs that have become local due to symbol
1010 visibility changes. */
1012 if (bfd_link_pic (info
))
1014 if (SYMBOL_CALLS_LOCAL (info
, h
))
1016 struct elf_dyn_relocs
**pp
;
1018 for (pp
= &h
->dyn_relocs
; (p
= *pp
) != NULL
; )
1020 p
->count
-= p
->pc_count
;
1029 /* Also discard relocs on undefined weak syms with non-default
1031 if (h
->dyn_relocs
!= NULL
1032 && h
->root
.type
== bfd_link_hash_undefweak
)
1034 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
1035 || UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
1036 h
->dyn_relocs
= NULL
;
1038 /* Make sure undefined weak symbols are output as a dynamic
1040 else if (h
->dynindx
== -1
1041 && !h
->forced_local
)
1043 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1050 /* For the non-shared case, discard space for relocs against
1051 symbols which turn out to need copy relocs or are not
1057 || (htab
->elf
.dynamic_sections_created
1058 && (h
->root
.type
== bfd_link_hash_undefweak
1059 || h
->root
.type
== bfd_link_hash_undefined
))))
1061 /* Make sure this symbol is output as a dynamic symbol.
1062 Undefined weak syms won't yet be marked as dynamic. */
1063 if (h
->dynindx
== -1
1064 && !h
->forced_local
)
1066 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1070 /* If that succeeded, we know we'll be keeping all the
1072 if (h
->dynindx
!= -1)
1076 h
->dyn_relocs
= NULL
;
1081 /* Finally, allocate space. */
1082 for (p
= h
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1084 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
1085 sreloc
->size
+= p
->count
* sizeof (ElfNN_External_Rela
);
1092 riscv_elf_size_dynamic_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
1094 struct riscv_elf_link_hash_table
*htab
;
1099 htab
= riscv_elf_hash_table (info
);
1100 BFD_ASSERT (htab
!= NULL
);
1101 dynobj
= htab
->elf
.dynobj
;
1102 BFD_ASSERT (dynobj
!= NULL
);
1104 if (elf_hash_table (info
)->dynamic_sections_created
)
1106 /* Set the contents of the .interp section to the interpreter. */
1107 if (bfd_link_executable (info
) && !info
->nointerp
)
1109 s
= bfd_get_linker_section (dynobj
, ".interp");
1110 BFD_ASSERT (s
!= NULL
);
1111 s
->size
= strlen (ELFNN_DYNAMIC_INTERPRETER
) + 1;
1112 s
->contents
= (unsigned char *) ELFNN_DYNAMIC_INTERPRETER
;
1116 /* Set up .got offsets for local syms, and space for local dynamic
1118 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
1120 bfd_signed_vma
*local_got
;
1121 bfd_signed_vma
*end_local_got
;
1122 char *local_tls_type
;
1123 bfd_size_type locsymcount
;
1124 Elf_Internal_Shdr
*symtab_hdr
;
1127 if (! is_riscv_elf (ibfd
))
1130 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
1132 struct elf_dyn_relocs
*p
;
1134 for (p
= elf_section_data (s
)->local_dynrel
; p
!= NULL
; p
= p
->next
)
1136 if (!bfd_is_abs_section (p
->sec
)
1137 && bfd_is_abs_section (p
->sec
->output_section
))
1139 /* Input section has been discarded, either because
1140 it is a copy of a linkonce section or due to
1141 linker script /DISCARD/, so we'll be discarding
1144 else if (p
->count
!= 0)
1146 srel
= elf_section_data (p
->sec
)->sreloc
;
1147 srel
->size
+= p
->count
* sizeof (ElfNN_External_Rela
);
1148 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
1149 info
->flags
|= DF_TEXTREL
;
1154 local_got
= elf_local_got_refcounts (ibfd
);
1158 symtab_hdr
= &elf_symtab_hdr (ibfd
);
1159 locsymcount
= symtab_hdr
->sh_info
;
1160 end_local_got
= local_got
+ locsymcount
;
1161 local_tls_type
= _bfd_riscv_elf_local_got_tls_type (ibfd
);
1163 srel
= htab
->elf
.srelgot
;
1164 for (; local_got
< end_local_got
; ++local_got
, ++local_tls_type
)
1168 *local_got
= s
->size
;
1169 s
->size
+= RISCV_ELF_WORD_BYTES
;
1170 if (*local_tls_type
& GOT_TLS_GD
)
1171 s
->size
+= RISCV_ELF_WORD_BYTES
;
1172 if (bfd_link_pic (info
)
1173 || (*local_tls_type
& (GOT_TLS_GD
| GOT_TLS_IE
)))
1174 srel
->size
+= sizeof (ElfNN_External_Rela
);
1177 *local_got
= (bfd_vma
) -1;
1181 /* Allocate global sym .plt and .got entries, and space for global
1182 sym dynamic relocs. */
1183 elf_link_hash_traverse (&htab
->elf
, allocate_dynrelocs
, info
);
1185 if (htab
->elf
.sgotplt
)
1187 struct elf_link_hash_entry
*got
;
1188 got
= elf_link_hash_lookup (elf_hash_table (info
),
1189 "_GLOBAL_OFFSET_TABLE_",
1190 FALSE
, FALSE
, FALSE
);
1192 /* Don't allocate .got.plt section if there are no GOT nor PLT
1193 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
1195 || !got
->ref_regular_nonweak
)
1196 && (htab
->elf
.sgotplt
->size
== GOTPLT_HEADER_SIZE
)
1197 && (htab
->elf
.splt
== NULL
1198 || htab
->elf
.splt
->size
== 0)
1199 && (htab
->elf
.sgot
== NULL
1200 || (htab
->elf
.sgot
->size
1201 == get_elf_backend_data (output_bfd
)->got_header_size
)))
1202 htab
->elf
.sgotplt
->size
= 0;
1205 /* The check_relocs and adjust_dynamic_symbol entry points have
1206 determined the sizes of the various dynamic sections. Allocate
1208 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1210 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1213 if (s
== htab
->elf
.splt
1214 || s
== htab
->elf
.sgot
1215 || s
== htab
->elf
.sgotplt
1216 || s
== htab
->elf
.sdynbss
1217 || s
== htab
->elf
.sdynrelro
1218 || s
== htab
->sdyntdata
)
1220 /* Strip this section if we don't need it; see the
1223 else if (strncmp (s
->name
, ".rela", 5) == 0)
1227 /* We use the reloc_count field as a counter if we need
1228 to copy relocs into the output file. */
1234 /* It's not one of our sections. */
1240 /* If we don't need this section, strip it from the
1241 output file. This is mostly to handle .rela.bss and
1242 .rela.plt. We must create both sections in
1243 create_dynamic_sections, because they must be created
1244 before the linker maps input sections to output
1245 sections. The linker does that before
1246 adjust_dynamic_symbol is called, and it is that
1247 function which decides whether anything needs to go
1248 into these sections. */
1249 s
->flags
|= SEC_EXCLUDE
;
1253 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
1256 /* Allocate memory for the section contents. Zero the memory
1257 for the benefit of .rela.plt, which has 4 unused entries
1258 at the beginning, and we don't want garbage. */
1259 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
1260 if (s
->contents
== NULL
)
1264 if (elf_hash_table (info
)->dynamic_sections_created
)
1266 /* Add some entries to the .dynamic section. We fill in the
1267 values later, in riscv_elf_finish_dynamic_sections, but we
1268 must add the entries now so that we get the correct size for
1269 the .dynamic section. The DT_DEBUG entry is filled in by the
1270 dynamic linker and used by the debugger. */
1271 #define add_dynamic_entry(TAG, VAL) \
1272 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1274 if (bfd_link_executable (info
))
1276 if (!add_dynamic_entry (DT_DEBUG
, 0))
1280 if (htab
->elf
.srelplt
->size
!= 0)
1282 if (!add_dynamic_entry (DT_PLTGOT
, 0)
1283 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
1284 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
1285 || !add_dynamic_entry (DT_JMPREL
, 0))
1289 if (!add_dynamic_entry (DT_RELA
, 0)
1290 || !add_dynamic_entry (DT_RELASZ
, 0)
1291 || !add_dynamic_entry (DT_RELAENT
, sizeof (ElfNN_External_Rela
)))
1294 /* If any dynamic relocs apply to a read-only section,
1295 then we need a DT_TEXTREL entry. */
1296 if ((info
->flags
& DF_TEXTREL
) == 0)
1297 elf_link_hash_traverse (&htab
->elf
,
1298 _bfd_elf_maybe_set_textrel
, info
);
1300 if (info
->flags
& DF_TEXTREL
)
1302 if (!add_dynamic_entry (DT_TEXTREL
, 0))
1306 #undef add_dynamic_entry
1312 #define DTP_OFFSET 0x800
1314 /* Return the relocation value for a TLS dtp-relative reloc. */
1317 dtpoff (struct bfd_link_info
*info
, bfd_vma address
)
1319 /* If tls_sec is NULL, we should have signalled an error already. */
1320 if (elf_hash_table (info
)->tls_sec
== NULL
)
1322 return address
- elf_hash_table (info
)->tls_sec
->vma
- DTP_OFFSET
;
1325 /* Return the relocation value for a static TLS tp-relative relocation. */
1328 tpoff (struct bfd_link_info
*info
, bfd_vma address
)
1330 /* If tls_sec is NULL, we should have signalled an error already. */
1331 if (elf_hash_table (info
)->tls_sec
== NULL
)
1333 return address
- elf_hash_table (info
)->tls_sec
->vma
- TP_OFFSET
;
1336 /* Return the global pointer's value, or 0 if it is not in use. */
1339 riscv_global_pointer_value (struct bfd_link_info
*info
)
1341 struct bfd_link_hash_entry
*h
;
1343 h
= bfd_link_hash_lookup (info
->hash
, RISCV_GP_SYMBOL
, FALSE
, FALSE
, TRUE
);
1344 if (h
== NULL
|| h
->type
!= bfd_link_hash_defined
)
1347 return h
->u
.def
.value
+ sec_addr (h
->u
.def
.section
);
1350 /* Emplace a static relocation. */
1352 static bfd_reloc_status_type
1353 perform_relocation (const reloc_howto_type
*howto
,
1354 const Elf_Internal_Rela
*rel
,
1356 asection
*input_section
,
1360 if (howto
->pc_relative
)
1361 value
-= sec_addr (input_section
) + rel
->r_offset
;
1362 value
+= rel
->r_addend
;
1364 switch (ELFNN_R_TYPE (rel
->r_info
))
1367 case R_RISCV_TPREL_HI20
:
1368 case R_RISCV_PCREL_HI20
:
1369 case R_RISCV_GOT_HI20
:
1370 case R_RISCV_TLS_GOT_HI20
:
1371 case R_RISCV_TLS_GD_HI20
:
1372 if (ARCH_SIZE
> 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (value
)))
1373 return bfd_reloc_overflow
;
1374 value
= ENCODE_UTYPE_IMM (RISCV_CONST_HIGH_PART (value
));
1377 case R_RISCV_LO12_I
:
1378 case R_RISCV_GPREL_I
:
1379 case R_RISCV_TPREL_LO12_I
:
1380 case R_RISCV_TPREL_I
:
1381 case R_RISCV_PCREL_LO12_I
:
1382 value
= ENCODE_ITYPE_IMM (value
);
1385 case R_RISCV_LO12_S
:
1386 case R_RISCV_GPREL_S
:
1387 case R_RISCV_TPREL_LO12_S
:
1388 case R_RISCV_TPREL_S
:
1389 case R_RISCV_PCREL_LO12_S
:
1390 value
= ENCODE_STYPE_IMM (value
);
1394 case R_RISCV_CALL_PLT
:
1395 if (ARCH_SIZE
> 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (value
)))
1396 return bfd_reloc_overflow
;
1397 value
= ENCODE_UTYPE_IMM (RISCV_CONST_HIGH_PART (value
))
1398 | (ENCODE_ITYPE_IMM (value
) << 32);
1402 if (!VALID_UJTYPE_IMM (value
))
1403 return bfd_reloc_overflow
;
1404 value
= ENCODE_UJTYPE_IMM (value
);
1407 case R_RISCV_BRANCH
:
1408 if (!VALID_SBTYPE_IMM (value
))
1409 return bfd_reloc_overflow
;
1410 value
= ENCODE_SBTYPE_IMM (value
);
1413 case R_RISCV_RVC_BRANCH
:
1414 if (!VALID_RVC_B_IMM (value
))
1415 return bfd_reloc_overflow
;
1416 value
= ENCODE_RVC_B_IMM (value
);
1419 case R_RISCV_RVC_JUMP
:
1420 if (!VALID_RVC_J_IMM (value
))
1421 return bfd_reloc_overflow
;
1422 value
= ENCODE_RVC_J_IMM (value
);
1425 case R_RISCV_RVC_LUI
:
1426 if (RISCV_CONST_HIGH_PART (value
) == 0)
1428 /* Linker relaxation can convert an address equal to or greater than
1429 0x800 to slightly below 0x800. C.LUI does not accept zero as a
1430 valid immediate. We can fix this by converting it to a C.LI. */
1431 bfd_vma insn
= bfd_get (howto
->bitsize
, input_bfd
,
1432 contents
+ rel
->r_offset
);
1433 insn
= (insn
& ~MATCH_C_LUI
) | MATCH_C_LI
;
1434 bfd_put (howto
->bitsize
, input_bfd
, insn
, contents
+ rel
->r_offset
);
1435 value
= ENCODE_RVC_IMM (0);
1437 else if (!VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (value
)))
1438 return bfd_reloc_overflow
;
1440 value
= ENCODE_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (value
));
1458 case R_RISCV_32_PCREL
:
1459 case R_RISCV_TLS_DTPREL32
:
1460 case R_RISCV_TLS_DTPREL64
:
1463 case R_RISCV_DELETE
:
1464 return bfd_reloc_ok
;
1467 return bfd_reloc_notsupported
;
1470 bfd_vma word
= bfd_get (howto
->bitsize
, input_bfd
, contents
+ rel
->r_offset
);
1471 word
= (word
& ~howto
->dst_mask
) | (value
& howto
->dst_mask
);
1472 bfd_put (howto
->bitsize
, input_bfd
, word
, contents
+ rel
->r_offset
);
1474 return bfd_reloc_ok
;
1477 /* Remember all PC-relative high-part relocs we've encountered to help us
1478 later resolve the corresponding low-part relocs. */
1484 } riscv_pcrel_hi_reloc
;
1486 typedef struct riscv_pcrel_lo_reloc
1488 asection
* input_section
;
1489 struct bfd_link_info
* info
;
1490 reloc_howto_type
* howto
;
1491 const Elf_Internal_Rela
* reloc
;
1494 bfd_byte
* contents
;
1495 struct riscv_pcrel_lo_reloc
* next
;
1496 } riscv_pcrel_lo_reloc
;
1501 riscv_pcrel_lo_reloc
*lo_relocs
;
1502 } riscv_pcrel_relocs
;
1505 riscv_pcrel_reloc_hash (const void *entry
)
1507 const riscv_pcrel_hi_reloc
*e
= entry
;
1508 return (hashval_t
)(e
->address
>> 2);
1512 riscv_pcrel_reloc_eq (const void *entry1
, const void *entry2
)
1514 const riscv_pcrel_hi_reloc
*e1
= entry1
, *e2
= entry2
;
1515 return e1
->address
== e2
->address
;
1519 riscv_init_pcrel_relocs (riscv_pcrel_relocs
*p
)
1522 p
->lo_relocs
= NULL
;
1523 p
->hi_relocs
= htab_create (1024, riscv_pcrel_reloc_hash
,
1524 riscv_pcrel_reloc_eq
, free
);
1525 return p
->hi_relocs
!= NULL
;
1529 riscv_free_pcrel_relocs (riscv_pcrel_relocs
*p
)
1531 riscv_pcrel_lo_reloc
*cur
= p
->lo_relocs
;
1535 riscv_pcrel_lo_reloc
*next
= cur
->next
;
1540 htab_delete (p
->hi_relocs
);
1544 riscv_zero_pcrel_hi_reloc (Elf_Internal_Rela
*rel
,
1545 struct bfd_link_info
*info
,
1549 const reloc_howto_type
*howto
,
1552 /* We may need to reference low addreses in PC-relative modes even when the
1553 * PC is far away from these addresses. For example, undefweak references
1554 * need to produce the address 0 when linked. As 0 is far from the arbitrary
1555 * addresses that we can link PC-relative programs at, the linker can't
1556 * actually relocate references to those symbols. In order to allow these
1557 * programs to work we simply convert the PC-relative auipc sequences to
1558 * 0-relative lui sequences. */
1559 if (bfd_link_pic (info
))
1562 /* If it's possible to reference the symbol using auipc we do so, as that's
1563 * more in the spirit of the PC-relative relocations we're processing. */
1564 bfd_vma offset
= addr
- pc
;
1565 if (ARCH_SIZE
== 32 || VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (offset
)))
1568 /* If it's impossible to reference this with a LUI-based offset then don't
1569 * bother to convert it at all so users still see the PC-relative relocation
1570 * in the truncation message. */
1571 if (ARCH_SIZE
> 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (addr
)))
1574 rel
->r_info
= ELFNN_R_INFO(addr
, R_RISCV_HI20
);
1576 bfd_vma insn
= bfd_get(howto
->bitsize
, input_bfd
, contents
+ rel
->r_offset
);
1577 insn
= (insn
& ~MASK_AUIPC
) | MATCH_LUI
;
1578 bfd_put(howto
->bitsize
, input_bfd
, insn
, contents
+ rel
->r_offset
);
1583 riscv_record_pcrel_hi_reloc (riscv_pcrel_relocs
*p
, bfd_vma addr
,
1584 bfd_vma value
, bfd_boolean absolute
)
1586 bfd_vma offset
= absolute
? value
: value
- addr
;
1587 riscv_pcrel_hi_reloc entry
= {addr
, offset
};
1588 riscv_pcrel_hi_reloc
**slot
=
1589 (riscv_pcrel_hi_reloc
**) htab_find_slot (p
->hi_relocs
, &entry
, INSERT
);
1591 BFD_ASSERT (*slot
== NULL
);
1592 *slot
= (riscv_pcrel_hi_reloc
*) bfd_malloc (sizeof (riscv_pcrel_hi_reloc
));
1600 riscv_record_pcrel_lo_reloc (riscv_pcrel_relocs
*p
,
1601 asection
*input_section
,
1602 struct bfd_link_info
*info
,
1603 reloc_howto_type
*howto
,
1604 const Elf_Internal_Rela
*reloc
,
1609 riscv_pcrel_lo_reloc
*entry
;
1610 entry
= (riscv_pcrel_lo_reloc
*) bfd_malloc (sizeof (riscv_pcrel_lo_reloc
));
1613 *entry
= (riscv_pcrel_lo_reloc
) {input_section
, info
, howto
, reloc
, addr
,
1614 name
, contents
, p
->lo_relocs
};
1615 p
->lo_relocs
= entry
;
1620 riscv_resolve_pcrel_lo_relocs (riscv_pcrel_relocs
*p
)
1622 riscv_pcrel_lo_reloc
*r
;
1624 for (r
= p
->lo_relocs
; r
!= NULL
; r
= r
->next
)
1626 bfd
*input_bfd
= r
->input_section
->owner
;
1628 riscv_pcrel_hi_reloc search
= {r
->addr
, 0};
1629 riscv_pcrel_hi_reloc
*entry
= htab_find (p
->hi_relocs
, &search
);
1631 /* Check for overflow into bit 11 when adding reloc addend. */
1632 || (! (entry
->value
& 0x800)
1633 && ((entry
->value
+ r
->reloc
->r_addend
) & 0x800)))
1635 char *string
= (entry
== NULL
1636 ? "%pcrel_lo missing matching %pcrel_hi"
1637 : "%pcrel_lo overflow with an addend");
1638 (*r
->info
->callbacks
->reloc_dangerous
)
1639 (r
->info
, string
, input_bfd
, r
->input_section
, r
->reloc
->r_offset
);
1643 perform_relocation (r
->howto
, r
->reloc
, entry
->value
, r
->input_section
,
1644 input_bfd
, r
->contents
);
1650 /* Relocate a RISC-V ELF section.
1652 The RELOCATE_SECTION function is called by the new ELF backend linker
1653 to handle the relocations for a section.
1655 The relocs are always passed as Rela structures.
1657 This function is responsible for adjusting the section contents as
1658 necessary, and (if generating a relocatable output file) adjusting
1659 the reloc addend as necessary.
1661 This function does not have to worry about setting the reloc
1662 address or the reloc symbol index.
1664 LOCAL_SYMS is a pointer to the swapped in local symbols.
1666 LOCAL_SECTIONS is an array giving the section in the input file
1667 corresponding to the st_shndx field of each local symbol.
1669 The global hash table entry for the global symbols can be found
1670 via elf_sym_hashes (input_bfd).
1672 When generating relocatable output, this function must handle
1673 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
1674 going to be the section symbol corresponding to the output
1675 section, which means that the addend must be adjusted
1679 riscv_elf_relocate_section (bfd
*output_bfd
,
1680 struct bfd_link_info
*info
,
1682 asection
*input_section
,
1684 Elf_Internal_Rela
*relocs
,
1685 Elf_Internal_Sym
*local_syms
,
1686 asection
**local_sections
)
1688 Elf_Internal_Rela
*rel
;
1689 Elf_Internal_Rela
*relend
;
1690 riscv_pcrel_relocs pcrel_relocs
;
1691 bfd_boolean ret
= FALSE
;
1692 asection
*sreloc
= elf_section_data (input_section
)->sreloc
;
1693 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
1694 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (input_bfd
);
1695 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (input_bfd
);
1696 bfd_vma
*local_got_offsets
= elf_local_got_offsets (input_bfd
);
1697 bfd_boolean absolute
;
1699 if (!riscv_init_pcrel_relocs (&pcrel_relocs
))
1702 relend
= relocs
+ input_section
->reloc_count
;
1703 for (rel
= relocs
; rel
< relend
; rel
++)
1705 unsigned long r_symndx
;
1706 struct elf_link_hash_entry
*h
;
1707 Elf_Internal_Sym
*sym
;
1710 bfd_reloc_status_type r
= bfd_reloc_ok
;
1712 bfd_vma off
, ie_off
;
1713 bfd_boolean unresolved_reloc
, is_ie
= FALSE
;
1714 bfd_vma pc
= sec_addr (input_section
) + rel
->r_offset
;
1715 int r_type
= ELFNN_R_TYPE (rel
->r_info
), tls_type
;
1716 reloc_howto_type
*howto
= riscv_elf_rtype_to_howto (input_bfd
, r_type
);
1717 const char *msg
= NULL
;
1718 char *msg_buf
= NULL
;
1719 bfd_boolean resolved_to_zero
;
1722 || r_type
== R_RISCV_GNU_VTINHERIT
|| r_type
== R_RISCV_GNU_VTENTRY
)
1725 /* This is a final link. */
1726 r_symndx
= ELFNN_R_SYM (rel
->r_info
);
1730 unresolved_reloc
= FALSE
;
1731 if (r_symndx
< symtab_hdr
->sh_info
)
1733 sym
= local_syms
+ r_symndx
;
1734 sec
= local_sections
[r_symndx
];
1735 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
1739 bfd_boolean warned
, ignored
;
1741 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
1742 r_symndx
, symtab_hdr
, sym_hashes
,
1744 unresolved_reloc
, warned
, ignored
);
1747 /* To avoid generating warning messages about truncated
1748 relocations, set the relocation's address to be the same as
1749 the start of this section. */
1750 if (input_section
->output_section
!= NULL
)
1751 relocation
= input_section
->output_section
->vma
;
1757 if (sec
!= NULL
&& discarded_section (sec
))
1758 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
1759 rel
, 1, relend
, howto
, 0, contents
);
1761 if (bfd_link_relocatable (info
))
1765 name
= h
->root
.root
.string
;
1768 name
= (bfd_elf_string_from_elf_section
1769 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
1770 if (name
== NULL
|| *name
== '\0')
1771 name
= bfd_section_name (sec
);
1774 resolved_to_zero
= (h
!= NULL
1775 && UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
));
1781 case R_RISCV_TPREL_ADD
:
1783 case R_RISCV_JUMP_SLOT
:
1784 case R_RISCV_RELATIVE
:
1785 /* These require nothing of us at all. */
1789 case R_RISCV_BRANCH
:
1790 case R_RISCV_RVC_BRANCH
:
1791 case R_RISCV_RVC_LUI
:
1792 case R_RISCV_LO12_I
:
1793 case R_RISCV_LO12_S
:
1798 case R_RISCV_32_PCREL
:
1799 case R_RISCV_DELETE
:
1800 /* These require no special handling beyond perform_relocation. */
1803 case R_RISCV_GOT_HI20
:
1806 bfd_boolean dyn
, pic
;
1808 off
= h
->got
.offset
;
1809 BFD_ASSERT (off
!= (bfd_vma
) -1);
1810 dyn
= elf_hash_table (info
)->dynamic_sections_created
;
1811 pic
= bfd_link_pic (info
);
1813 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, pic
, h
)
1814 || (pic
&& SYMBOL_REFERENCES_LOCAL (info
, h
)))
1816 /* This is actually a static link, or it is a
1817 -Bsymbolic link and the symbol is defined
1818 locally, or the symbol was forced to be local
1819 because of a version file. We must initialize
1820 this entry in the global offset table. Since the
1821 offset must always be a multiple of the word size,
1822 we use the least significant bit to record whether
1823 we have initialized it already.
1825 When doing a dynamic link, we create a .rela.got
1826 relocation entry to initialize the value. This
1827 is done in the finish_dynamic_symbol routine. */
1832 bfd_put_NN (output_bfd
, relocation
,
1833 htab
->elf
.sgot
->contents
+ off
);
1838 unresolved_reloc
= FALSE
;
1842 BFD_ASSERT (local_got_offsets
!= NULL
1843 && local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
1845 off
= local_got_offsets
[r_symndx
];
1847 /* The offset must always be a multiple of the word size.
1848 So, we can use the least significant bit to record
1849 whether we have already processed this entry. */
1854 if (bfd_link_pic (info
))
1857 Elf_Internal_Rela outrel
;
1859 /* We need to generate a R_RISCV_RELATIVE reloc
1860 for the dynamic linker. */
1861 s
= htab
->elf
.srelgot
;
1862 BFD_ASSERT (s
!= NULL
);
1864 outrel
.r_offset
= sec_addr (htab
->elf
.sgot
) + off
;
1866 ELFNN_R_INFO (0, R_RISCV_RELATIVE
);
1867 outrel
.r_addend
= relocation
;
1869 riscv_elf_append_rela (output_bfd
, s
, &outrel
);
1872 bfd_put_NN (output_bfd
, relocation
,
1873 htab
->elf
.sgot
->contents
+ off
);
1874 local_got_offsets
[r_symndx
] |= 1;
1877 relocation
= sec_addr (htab
->elf
.sgot
) + off
;
1878 absolute
= riscv_zero_pcrel_hi_reloc (rel
,
1885 r_type
= ELFNN_R_TYPE (rel
->r_info
);
1886 howto
= riscv_elf_rtype_to_howto (input_bfd
, r_type
);
1888 r
= bfd_reloc_notsupported
;
1889 else if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs
, pc
,
1890 relocation
, absolute
))
1891 r
= bfd_reloc_overflow
;
1899 bfd_vma old_value
= bfd_get (howto
->bitsize
, input_bfd
,
1900 contents
+ rel
->r_offset
);
1901 relocation
= old_value
+ relocation
;
1911 bfd_vma old_value
= bfd_get (howto
->bitsize
, input_bfd
,
1912 contents
+ rel
->r_offset
);
1913 relocation
= old_value
- relocation
;
1918 case R_RISCV_CALL_PLT
:
1919 /* Handle a call to an undefined weak function. This won't be
1920 relaxed, so we have to handle it here. */
1921 if (h
!= NULL
&& h
->root
.type
== bfd_link_hash_undefweak
1922 && (!bfd_link_pic (info
) || h
->plt
.offset
== MINUS_ONE
))
1924 /* We can use x0 as the base register. */
1925 bfd_vma insn
= bfd_get_32 (input_bfd
,
1926 contents
+ rel
->r_offset
+ 4);
1927 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
1928 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
+ 4);
1929 /* Set the relocation value so that we get 0 after the pc
1930 relative adjustment. */
1931 relocation
= sec_addr (input_section
) + rel
->r_offset
;
1936 case R_RISCV_RVC_JUMP
:
1937 /* This line has to match the check in _bfd_riscv_relax_section. */
1938 if (bfd_link_pic (info
) && h
!= NULL
&& h
->plt
.offset
!= MINUS_ONE
)
1940 /* Refer to the PLT entry. */
1941 relocation
= sec_addr (htab
->elf
.splt
) + h
->plt
.offset
;
1942 unresolved_reloc
= FALSE
;
1946 case R_RISCV_TPREL_HI20
:
1947 relocation
= tpoff (info
, relocation
);
1950 case R_RISCV_TPREL_LO12_I
:
1951 case R_RISCV_TPREL_LO12_S
:
1952 relocation
= tpoff (info
, relocation
);
1955 case R_RISCV_TPREL_I
:
1956 case R_RISCV_TPREL_S
:
1957 relocation
= tpoff (info
, relocation
);
1958 if (VALID_ITYPE_IMM (relocation
+ rel
->r_addend
))
1960 /* We can use tp as the base register. */
1961 bfd_vma insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
1962 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
1963 insn
|= X_TP
<< OP_SH_RS1
;
1964 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
1967 r
= bfd_reloc_overflow
;
1970 case R_RISCV_GPREL_I
:
1971 case R_RISCV_GPREL_S
:
1973 bfd_vma gp
= riscv_global_pointer_value (info
);
1974 bfd_boolean x0_base
= VALID_ITYPE_IMM (relocation
+ rel
->r_addend
);
1975 if (x0_base
|| VALID_ITYPE_IMM (relocation
+ rel
->r_addend
- gp
))
1977 /* We can use x0 or gp as the base register. */
1978 bfd_vma insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
1979 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
1982 rel
->r_addend
-= gp
;
1983 insn
|= X_GP
<< OP_SH_RS1
;
1985 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
1988 r
= bfd_reloc_overflow
;
1992 case R_RISCV_PCREL_HI20
:
1993 absolute
= riscv_zero_pcrel_hi_reloc (rel
,
2000 r_type
= ELFNN_R_TYPE (rel
->r_info
);
2001 howto
= riscv_elf_rtype_to_howto (input_bfd
, r_type
);
2003 r
= bfd_reloc_notsupported
;
2004 else if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs
, pc
,
2005 relocation
+ rel
->r_addend
,
2007 r
= bfd_reloc_overflow
;
2010 case R_RISCV_PCREL_LO12_I
:
2011 case R_RISCV_PCREL_LO12_S
:
2012 /* We don't allow section symbols plus addends as the auipc address,
2013 because then riscv_relax_delete_bytes would have to search through
2014 all relocs to update these addends. This is also ambiguous, as
2015 we do allow offsets to be added to the target address, which are
2016 not to be used to find the auipc address. */
2017 if (((sym
!= NULL
&& (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
))
2018 || (h
!= NULL
&& h
->type
== STT_SECTION
))
2021 msg
= _("%pcrel_lo section symbol with an addend");
2022 r
= bfd_reloc_dangerous
;
2026 if (riscv_record_pcrel_lo_reloc (&pcrel_relocs
, input_section
, info
,
2027 howto
, rel
, relocation
, name
,
2030 r
= bfd_reloc_overflow
;
2033 case R_RISCV_TLS_DTPREL32
:
2034 case R_RISCV_TLS_DTPREL64
:
2035 relocation
= dtpoff (info
, relocation
);
2040 if ((input_section
->flags
& SEC_ALLOC
) == 0)
2043 if ((bfd_link_pic (info
)
2045 || (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2046 && !resolved_to_zero
)
2047 || h
->root
.type
!= bfd_link_hash_undefweak
)
2048 && (! howto
->pc_relative
2049 || !SYMBOL_CALLS_LOCAL (info
, h
)))
2050 || (!bfd_link_pic (info
)
2056 || h
->root
.type
== bfd_link_hash_undefweak
2057 || h
->root
.type
== bfd_link_hash_undefined
)))
2059 Elf_Internal_Rela outrel
;
2060 bfd_boolean skip_static_relocation
, skip_dynamic_relocation
;
2062 /* When generating a shared object, these relocations
2063 are copied into the output file to be resolved at run
2067 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
2069 skip_static_relocation
= outrel
.r_offset
!= (bfd_vma
) -2;
2070 skip_dynamic_relocation
= outrel
.r_offset
>= (bfd_vma
) -2;
2071 outrel
.r_offset
+= sec_addr (input_section
);
2073 if (skip_dynamic_relocation
)
2074 memset (&outrel
, 0, sizeof outrel
);
2075 else if (h
!= NULL
&& h
->dynindx
!= -1
2076 && !(bfd_link_pic (info
)
2077 && SYMBOLIC_BIND (info
, h
)
2080 outrel
.r_info
= ELFNN_R_INFO (h
->dynindx
, r_type
);
2081 outrel
.r_addend
= rel
->r_addend
;
2085 outrel
.r_info
= ELFNN_R_INFO (0, R_RISCV_RELATIVE
);
2086 outrel
.r_addend
= relocation
+ rel
->r_addend
;
2089 riscv_elf_append_rela (output_bfd
, sreloc
, &outrel
);
2090 if (skip_static_relocation
)
2095 case R_RISCV_TLS_GOT_HI20
:
2099 case R_RISCV_TLS_GD_HI20
:
2102 off
= h
->got
.offset
;
2107 off
= local_got_offsets
[r_symndx
];
2108 local_got_offsets
[r_symndx
] |= 1;
2111 tls_type
= _bfd_riscv_elf_tls_type (input_bfd
, h
, r_symndx
);
2112 BFD_ASSERT (tls_type
& (GOT_TLS_IE
| GOT_TLS_GD
));
2113 /* If this symbol is referenced by both GD and IE TLS, the IE
2114 reference's GOT slot follows the GD reference's slots. */
2116 if ((tls_type
& GOT_TLS_GD
) && (tls_type
& GOT_TLS_IE
))
2117 ie_off
= 2 * GOT_ENTRY_SIZE
;
2123 Elf_Internal_Rela outrel
;
2125 bfd_boolean need_relocs
= FALSE
;
2127 if (htab
->elf
.srelgot
== NULL
)
2132 bfd_boolean dyn
, pic
;
2133 dyn
= htab
->elf
.dynamic_sections_created
;
2134 pic
= bfd_link_pic (info
);
2136 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, pic
, h
)
2137 && (!pic
|| !SYMBOL_REFERENCES_LOCAL (info
, h
)))
2141 /* The GOT entries have not been initialized yet. Do it
2142 now, and emit any relocations. */
2143 if ((bfd_link_pic (info
) || indx
!= 0)
2145 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2146 || h
->root
.type
!= bfd_link_hash_undefweak
))
2149 if (tls_type
& GOT_TLS_GD
)
2153 outrel
.r_offset
= sec_addr (htab
->elf
.sgot
) + off
;
2154 outrel
.r_addend
= 0;
2155 outrel
.r_info
= ELFNN_R_INFO (indx
, R_RISCV_TLS_DTPMODNN
);
2156 bfd_put_NN (output_bfd
, 0,
2157 htab
->elf
.sgot
->contents
+ off
);
2158 riscv_elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &outrel
);
2161 BFD_ASSERT (! unresolved_reloc
);
2162 bfd_put_NN (output_bfd
,
2163 dtpoff (info
, relocation
),
2164 (htab
->elf
.sgot
->contents
+ off
+
2165 RISCV_ELF_WORD_BYTES
));
2169 bfd_put_NN (output_bfd
, 0,
2170 (htab
->elf
.sgot
->contents
+ off
+
2171 RISCV_ELF_WORD_BYTES
));
2172 outrel
.r_info
= ELFNN_R_INFO (indx
, R_RISCV_TLS_DTPRELNN
);
2173 outrel
.r_offset
+= RISCV_ELF_WORD_BYTES
;
2174 riscv_elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &outrel
);
2179 /* If we are not emitting relocations for a
2180 general dynamic reference, then we must be in a
2181 static link or an executable link with the
2182 symbol binding locally. Mark it as belonging
2183 to module 1, the executable. */
2184 bfd_put_NN (output_bfd
, 1,
2185 htab
->elf
.sgot
->contents
+ off
);
2186 bfd_put_NN (output_bfd
,
2187 dtpoff (info
, relocation
),
2188 (htab
->elf
.sgot
->contents
+ off
+
2189 RISCV_ELF_WORD_BYTES
));
2193 if (tls_type
& GOT_TLS_IE
)
2197 bfd_put_NN (output_bfd
, 0,
2198 htab
->elf
.sgot
->contents
+ off
+ ie_off
);
2199 outrel
.r_offset
= sec_addr (htab
->elf
.sgot
)
2201 outrel
.r_addend
= 0;
2203 outrel
.r_addend
= tpoff (info
, relocation
);
2204 outrel
.r_info
= ELFNN_R_INFO (indx
, R_RISCV_TLS_TPRELNN
);
2205 riscv_elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &outrel
);
2209 bfd_put_NN (output_bfd
, tpoff (info
, relocation
),
2210 htab
->elf
.sgot
->contents
+ off
+ ie_off
);
2215 BFD_ASSERT (off
< (bfd_vma
) -2);
2216 relocation
= sec_addr (htab
->elf
.sgot
) + off
+ (is_ie
? ie_off
: 0);
2217 if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs
, pc
,
2219 r
= bfd_reloc_overflow
;
2220 unresolved_reloc
= FALSE
;
2224 r
= bfd_reloc_notsupported
;
2227 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2228 because such sections are not SEC_ALLOC and thus ld.so will
2229 not process them. */
2230 if (unresolved_reloc
2231 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
2233 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
2234 rel
->r_offset
) != (bfd_vma
) -1)
2240 case R_RISCV_RVC_JUMP
:
2241 if (asprintf (&msg_buf
,
2242 _("%%X%%P: relocation %s against `%s' can "
2243 "not be used when making a shared object; "
2244 "recompile with -fPIC\n"),
2246 h
->root
.root
.string
) == -1)
2251 if (asprintf (&msg_buf
,
2252 _("%%X%%P: unresolvable %s relocation against "
2255 h
->root
.root
.string
) == -1)
2261 r
= bfd_reloc_notsupported
;
2264 if (r
== bfd_reloc_ok
)
2265 r
= perform_relocation (howto
, rel
, relocation
, input_section
,
2266 input_bfd
, contents
);
2268 /* We should have already detected the error and set message before.
2269 If the error message isn't set since the linker runs out of memory
2270 or we don't set it before, then we should set the default message
2271 with the "internal error" string here. */
2277 case bfd_reloc_overflow
:
2278 info
->callbacks
->reloc_overflow
2279 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
2280 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
2283 case bfd_reloc_undefined
:
2284 info
->callbacks
->undefined_symbol
2285 (info
, name
, input_bfd
, input_section
, rel
->r_offset
,
2289 case bfd_reloc_outofrange
:
2291 msg
= _("%X%P: internal error: out of range error\n");
2294 case bfd_reloc_notsupported
:
2296 msg
= _("%X%P: internal error: unsupported relocation error\n");
2299 case bfd_reloc_dangerous
:
2300 /* The error message should already be set. */
2302 msg
= _("dangerous relocation error");
2303 info
->callbacks
->reloc_dangerous
2304 (info
, msg
, input_bfd
, input_section
, rel
->r_offset
);
2308 msg
= _("%X%P: internal error: unknown error\n");
2312 /* Do not report error message for the dangerous relocation again. */
2313 if (msg
&& r
!= bfd_reloc_dangerous
)
2314 info
->callbacks
->einfo (msg
);
2316 /* Free the unused `msg_buf`. */
2319 /* We already reported the error via a callback, so don't try to report
2320 it again by returning false. That leads to spurious errors. */
2325 ret
= riscv_resolve_pcrel_lo_relocs (&pcrel_relocs
);
2327 riscv_free_pcrel_relocs (&pcrel_relocs
);
2331 /* Finish up dynamic symbol handling. We set the contents of various
2332 dynamic sections here. */
2335 riscv_elf_finish_dynamic_symbol (bfd
*output_bfd
,
2336 struct bfd_link_info
*info
,
2337 struct elf_link_hash_entry
*h
,
2338 Elf_Internal_Sym
*sym
)
2340 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
2341 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
2343 if (h
->plt
.offset
!= (bfd_vma
) -1)
2345 /* We've decided to create a PLT entry for this symbol. */
2347 bfd_vma i
, header_address
, plt_idx
, got_address
;
2348 uint32_t plt_entry
[PLT_ENTRY_INSNS
];
2349 Elf_Internal_Rela rela
;
2351 BFD_ASSERT (h
->dynindx
!= -1);
2353 /* Calculate the address of the PLT header. */
2354 header_address
= sec_addr (htab
->elf
.splt
);
2356 /* Calculate the index of the entry. */
2357 plt_idx
= (h
->plt
.offset
- PLT_HEADER_SIZE
) / PLT_ENTRY_SIZE
;
2359 /* Calculate the address of the .got.plt entry. */
2360 got_address
= riscv_elf_got_plt_val (plt_idx
, info
);
2362 /* Find out where the .plt entry should go. */
2363 loc
= htab
->elf
.splt
->contents
+ h
->plt
.offset
;
2365 /* Fill in the PLT entry itself. */
2366 if (! riscv_make_plt_entry (output_bfd
, got_address
,
2367 header_address
+ h
->plt
.offset
,
2371 for (i
= 0; i
< PLT_ENTRY_INSNS
; i
++)
2372 bfd_put_32 (output_bfd
, plt_entry
[i
], loc
+ 4*i
);
2374 /* Fill in the initial value of the .got.plt entry. */
2375 loc
= htab
->elf
.sgotplt
->contents
2376 + (got_address
- sec_addr (htab
->elf
.sgotplt
));
2377 bfd_put_NN (output_bfd
, sec_addr (htab
->elf
.splt
), loc
);
2379 /* Fill in the entry in the .rela.plt section. */
2380 rela
.r_offset
= got_address
;
2382 rela
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_RISCV_JUMP_SLOT
);
2384 loc
= htab
->elf
.srelplt
->contents
+ plt_idx
* sizeof (ElfNN_External_Rela
);
2385 bed
->s
->swap_reloca_out (output_bfd
, &rela
, loc
);
2387 if (!h
->def_regular
)
2389 /* Mark the symbol as undefined, rather than as defined in
2390 the .plt section. Leave the value alone. */
2391 sym
->st_shndx
= SHN_UNDEF
;
2392 /* If the symbol is weak, we do need to clear the value.
2393 Otherwise, the PLT entry would provide a definition for
2394 the symbol even if the symbol wasn't defined anywhere,
2395 and so the symbol would never be NULL. */
2396 if (!h
->ref_regular_nonweak
)
2401 if (h
->got
.offset
!= (bfd_vma
) -1
2402 && !(riscv_elf_hash_entry (h
)->tls_type
& (GOT_TLS_GD
| GOT_TLS_IE
))
2403 && !UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
2407 Elf_Internal_Rela rela
;
2409 /* This symbol has an entry in the GOT. Set it up. */
2411 sgot
= htab
->elf
.sgot
;
2412 srela
= htab
->elf
.srelgot
;
2413 BFD_ASSERT (sgot
!= NULL
&& srela
!= NULL
);
2415 rela
.r_offset
= sec_addr (sgot
) + (h
->got
.offset
&~ (bfd_vma
) 1);
2417 /* If this is a local symbol reference, we just want to emit a RELATIVE
2418 reloc. This can happen if it is a -Bsymbolic link, or a pie link, or
2419 the symbol was forced to be local because of a version file.
2420 The entry in the global offset table will already have been
2421 initialized in the relocate_section function. */
2422 if (bfd_link_pic (info
)
2423 && SYMBOL_REFERENCES_LOCAL (info
, h
))
2425 BFD_ASSERT((h
->got
.offset
& 1) != 0);
2426 asection
*sec
= h
->root
.u
.def
.section
;
2427 rela
.r_info
= ELFNN_R_INFO (0, R_RISCV_RELATIVE
);
2428 rela
.r_addend
= (h
->root
.u
.def
.value
2429 + sec
->output_section
->vma
2430 + sec
->output_offset
);
2434 BFD_ASSERT((h
->got
.offset
& 1) == 0);
2435 BFD_ASSERT (h
->dynindx
!= -1);
2436 rela
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_RISCV_NN
);
2440 bfd_put_NN (output_bfd
, 0,
2441 sgot
->contents
+ (h
->got
.offset
& ~(bfd_vma
) 1));
2442 riscv_elf_append_rela (output_bfd
, srela
, &rela
);
2447 Elf_Internal_Rela rela
;
2450 /* This symbols needs a copy reloc. Set it up. */
2451 BFD_ASSERT (h
->dynindx
!= -1);
2453 rela
.r_offset
= sec_addr (h
->root
.u
.def
.section
) + h
->root
.u
.def
.value
;
2454 rela
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_RISCV_COPY
);
2456 if (h
->root
.u
.def
.section
== htab
->elf
.sdynrelro
)
2457 s
= htab
->elf
.sreldynrelro
;
2459 s
= htab
->elf
.srelbss
;
2460 riscv_elf_append_rela (output_bfd
, s
, &rela
);
2463 /* Mark some specially defined symbols as absolute. */
2464 if (h
== htab
->elf
.hdynamic
2465 || (h
== htab
->elf
.hgot
|| h
== htab
->elf
.hplt
))
2466 sym
->st_shndx
= SHN_ABS
;
2471 /* Finish up the dynamic sections. */
2474 riscv_finish_dyn (bfd
*output_bfd
, struct bfd_link_info
*info
,
2475 bfd
*dynobj
, asection
*sdyn
)
2477 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
2478 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
2479 size_t dynsize
= bed
->s
->sizeof_dyn
;
2480 bfd_byte
*dyncon
, *dynconend
;
2482 dynconend
= sdyn
->contents
+ sdyn
->size
;
2483 for (dyncon
= sdyn
->contents
; dyncon
< dynconend
; dyncon
+= dynsize
)
2485 Elf_Internal_Dyn dyn
;
2488 bed
->s
->swap_dyn_in (dynobj
, dyncon
, &dyn
);
2493 s
= htab
->elf
.sgotplt
;
2494 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
2497 s
= htab
->elf
.srelplt
;
2498 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
2501 s
= htab
->elf
.srelplt
;
2502 dyn
.d_un
.d_val
= s
->size
;
2508 bed
->s
->swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2514 riscv_elf_finish_dynamic_sections (bfd
*output_bfd
,
2515 struct bfd_link_info
*info
)
2519 struct riscv_elf_link_hash_table
*htab
;
2521 htab
= riscv_elf_hash_table (info
);
2522 BFD_ASSERT (htab
!= NULL
);
2523 dynobj
= htab
->elf
.dynobj
;
2525 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
2527 if (elf_hash_table (info
)->dynamic_sections_created
)
2532 splt
= htab
->elf
.splt
;
2533 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
2535 ret
= riscv_finish_dyn (output_bfd
, info
, dynobj
, sdyn
);
2540 /* Fill in the head and tail entries in the procedure linkage table. */
2544 uint32_t plt_header
[PLT_HEADER_INSNS
];
2545 ret
= riscv_make_plt_header (output_bfd
,
2546 sec_addr (htab
->elf
.sgotplt
),
2547 sec_addr (splt
), plt_header
);
2551 for (i
= 0; i
< PLT_HEADER_INSNS
; i
++)
2552 bfd_put_32 (output_bfd
, plt_header
[i
], splt
->contents
+ 4*i
);
2554 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
2559 if (htab
->elf
.sgotplt
)
2561 asection
*output_section
= htab
->elf
.sgotplt
->output_section
;
2563 if (bfd_is_abs_section (output_section
))
2565 (*_bfd_error_handler
)
2566 (_("discarded output section: `%pA'"), htab
->elf
.sgotplt
);
2570 if (htab
->elf
.sgotplt
->size
> 0)
2572 /* Write the first two entries in .got.plt, needed for the dynamic
2574 bfd_put_NN (output_bfd
, (bfd_vma
) -1, htab
->elf
.sgotplt
->contents
);
2575 bfd_put_NN (output_bfd
, (bfd_vma
) 0,
2576 htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
);
2579 elf_section_data (output_section
)->this_hdr
.sh_entsize
= GOT_ENTRY_SIZE
;
2584 asection
*output_section
= htab
->elf
.sgot
->output_section
;
2586 if (htab
->elf
.sgot
->size
> 0)
2588 /* Set the first entry in the global offset table to the address of
2589 the dynamic section. */
2590 bfd_vma val
= sdyn
? sec_addr (sdyn
) : 0;
2591 bfd_put_NN (output_bfd
, val
, htab
->elf
.sgot
->contents
);
2594 elf_section_data (output_section
)->this_hdr
.sh_entsize
= GOT_ENTRY_SIZE
;
2600 /* Return address for Ith PLT stub in section PLT, for relocation REL
2601 or (bfd_vma) -1 if it should not be included. */
2604 riscv_elf_plt_sym_val (bfd_vma i
, const asection
*plt
,
2605 const arelent
*rel ATTRIBUTE_UNUSED
)
2607 return plt
->vma
+ PLT_HEADER_SIZE
+ i
* PLT_ENTRY_SIZE
;
2610 static enum elf_reloc_type_class
2611 riscv_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2612 const asection
*rel_sec ATTRIBUTE_UNUSED
,
2613 const Elf_Internal_Rela
*rela
)
2615 switch (ELFNN_R_TYPE (rela
->r_info
))
2617 case R_RISCV_RELATIVE
:
2618 return reloc_class_relative
;
2619 case R_RISCV_JUMP_SLOT
:
2620 return reloc_class_plt
;
2622 return reloc_class_copy
;
2624 return reloc_class_normal
;
2628 /* Given the ELF header flags in FLAGS, it returns a string that describes the
2632 riscv_float_abi_string (flagword flags
)
2634 switch (flags
& EF_RISCV_FLOAT_ABI
)
2636 case EF_RISCV_FLOAT_ABI_SOFT
:
2637 return "soft-float";
2639 case EF_RISCV_FLOAT_ABI_SINGLE
:
2640 return "single-float";
2642 case EF_RISCV_FLOAT_ABI_DOUBLE
:
2643 return "double-float";
2645 case EF_RISCV_FLOAT_ABI_QUAD
:
2646 return "quad-float";
2653 /* The information of architecture attribute. */
2654 static riscv_subset_list_t in_subsets
;
2655 static riscv_subset_list_t out_subsets
;
2656 static riscv_subset_list_t merged_subsets
;
2658 /* Predicator for standard extension. */
2661 riscv_std_ext_p (const char *name
)
2663 return (strlen (name
) == 1) && (name
[0] != 'x') && (name
[0] != 's');
2666 /* Error handler when version mis-match. */
2669 riscv_version_mismatch (bfd
*ibfd
,
2670 struct riscv_subset_t
*in
,
2671 struct riscv_subset_t
*out
)
2674 (_("error: %pB: Mis-matched ISA version for '%s' extension. "
2677 in
->major_version
, in
->minor_version
,
2678 out
->major_version
, out
->minor_version
);
2681 /* Return true if subset is 'i' or 'e'. */
2684 riscv_i_or_e_p (bfd
*ibfd
,
2686 struct riscv_subset_t
*subset
)
2688 if ((strcasecmp (subset
->name
, "e") != 0)
2689 && (strcasecmp (subset
->name
, "i") != 0))
2692 (_("error: %pB: corrupted ISA string '%s'. "
2693 "First letter should be 'i' or 'e' but got '%s'."),
2694 ibfd
, arch
, subset
->name
);
2700 /* Merge standard extensions.
2703 Return FALSE if failed to merge.
2707 `in_arch`: Raw arch string for input object.
2708 `out_arch`: Raw arch string for output object.
2709 `pin`: subset list for input object, and it'll skip all merged subset after
2711 `pout`: Like `pin`, but for output object. */
2714 riscv_merge_std_ext (bfd
*ibfd
,
2715 const char *in_arch
,
2716 const char *out_arch
,
2717 struct riscv_subset_t
**pin
,
2718 struct riscv_subset_t
**pout
)
2720 const char *standard_exts
= riscv_supported_std_ext ();
2722 struct riscv_subset_t
*in
= *pin
;
2723 struct riscv_subset_t
*out
= *pout
;
2725 /* First letter should be 'i' or 'e'. */
2726 if (!riscv_i_or_e_p (ibfd
, in_arch
, in
))
2729 if (!riscv_i_or_e_p (ibfd
, out_arch
, out
))
2732 if (strcasecmp (in
->name
, out
->name
) != 0)
2734 /* TODO: We might allow merge 'i' with 'e'. */
2736 (_("error: %pB: Mis-matched ISA string to merge '%s' and '%s'."),
2737 ibfd
, in
->name
, out
->name
);
2740 else if ((in
->major_version
!= out
->major_version
) ||
2741 (in
->minor_version
!= out
->minor_version
))
2743 /* TODO: Allow different merge policy. */
2744 riscv_version_mismatch (ibfd
, in
, out
);
2748 riscv_add_subset (&merged_subsets
,
2749 in
->name
, in
->major_version
, in
->minor_version
);
2754 /* Handle standard extension first. */
2755 for (p
= standard_exts
; *p
; ++p
)
2757 char find_ext
[2] = {*p
, '\0'};
2758 struct riscv_subset_t
*find_in
=
2759 riscv_lookup_subset (&in_subsets
, find_ext
);
2760 struct riscv_subset_t
*find_out
=
2761 riscv_lookup_subset (&out_subsets
, find_ext
);
2763 if (find_in
== NULL
&& find_out
== NULL
)
2766 /* Check version is same or not. */
2767 /* TODO: Allow different merge policy. */
2768 if ((find_in
!= NULL
&& find_out
!= NULL
)
2769 && ((find_in
->major_version
!= find_out
->major_version
)
2770 || (find_in
->minor_version
!= find_out
->minor_version
)))
2772 riscv_version_mismatch (ibfd
, in
, out
);
2776 struct riscv_subset_t
*merged
= find_in
? find_in
: find_out
;
2777 riscv_add_subset (&merged_subsets
, merged
->name
,
2778 merged
->major_version
, merged
->minor_version
);
2781 /* Skip all standard extensions. */
2782 while ((in
!= NULL
) && riscv_std_ext_p (in
->name
)) in
= in
->next
;
2783 while ((out
!= NULL
) && riscv_std_ext_p (out
->name
)) out
= out
->next
;
2791 /* If C is a prefix class, then return the EXT string without the prefix.
2792 Otherwise return the entire EXT string. */
2795 riscv_skip_prefix (const char *ext
, riscv_isa_ext_class_t c
)
2799 case RV_ISA_CLASS_X
: return &ext
[1];
2800 case RV_ISA_CLASS_S
: return &ext
[1];
2801 case RV_ISA_CLASS_Z
: return &ext
[1];
2802 default: return ext
;
2806 /* Compare prefixed extension names canonically. */
2809 riscv_prefix_cmp (const char *a
, const char *b
)
2811 riscv_isa_ext_class_t ca
= riscv_get_prefix_class (a
);
2812 riscv_isa_ext_class_t cb
= riscv_get_prefix_class (b
);
2814 /* Extension name without prefix */
2815 const char *anp
= riscv_skip_prefix (a
, ca
);
2816 const char *bnp
= riscv_skip_prefix (b
, cb
);
2819 return strcasecmp (anp
, bnp
);
2821 return (int)ca
- (int)cb
;
2824 /* Merge multi letter extensions. PIN is a pointer to the head of the input
2825 object subset list. Likewise for POUT and the output object. Return TRUE
2826 on success and FALSE when a conflict is found. */
2829 riscv_merge_multi_letter_ext (bfd
*ibfd
,
2830 riscv_subset_t
**pin
,
2831 riscv_subset_t
**pout
)
2833 riscv_subset_t
*in
= *pin
;
2834 riscv_subset_t
*out
= *pout
;
2835 riscv_subset_t
*tail
;
2841 cmp
= riscv_prefix_cmp (in
->name
, out
->name
);
2845 /* `in' comes before `out', append `in' and increment. */
2846 riscv_add_subset (&merged_subsets
, in
->name
, in
->major_version
,
2852 /* `out' comes before `in', append `out' and increment. */
2853 riscv_add_subset (&merged_subsets
, out
->name
, out
->major_version
,
2854 out
->minor_version
);
2859 /* Both present, check version and increment both. */
2860 if ((in
->major_version
!= out
->major_version
)
2861 || (in
->minor_version
!= out
->minor_version
))
2863 riscv_version_mismatch (ibfd
, in
, out
);
2867 riscv_add_subset (&merged_subsets
, out
->name
, out
->major_version
,
2868 out
->minor_version
);
2875 /* If we're here, either `in' or `out' is running longer than
2876 the other. So, we need to append the corresponding tail. */
2877 tail
= in
? in
: out
;
2881 riscv_add_subset (&merged_subsets
, tail
->name
, tail
->major_version
,
2882 tail
->minor_version
);
2890 /* Merge Tag_RISCV_arch attribute. */
2893 riscv_merge_arch_attr_info (bfd
*ibfd
, char *in_arch
, char *out_arch
)
2895 riscv_subset_t
*in
, *out
;
2896 char *merged_arch_str
;
2898 unsigned xlen_in
, xlen_out
;
2899 merged_subsets
.head
= NULL
;
2900 merged_subsets
.tail
= NULL
;
2902 riscv_parse_subset_t rpe_in
;
2903 riscv_parse_subset_t rpe_out
;
2905 /* Only assembler needs to check the default version of ISA, so just set
2906 the rpe_in.get_default_version and rpe_out.get_default_version to NULL. */
2907 rpe_in
.subset_list
= &in_subsets
;
2908 rpe_in
.error_handler
= _bfd_error_handler
;
2909 rpe_in
.xlen
= &xlen_in
;
2910 rpe_in
.get_default_version
= NULL
;
2912 rpe_out
.subset_list
= &out_subsets
;
2913 rpe_out
.error_handler
= _bfd_error_handler
;
2914 rpe_out
.xlen
= &xlen_out
;
2915 rpe_out
.get_default_version
= NULL
;
2917 if (in_arch
== NULL
&& out_arch
== NULL
)
2920 if (in_arch
== NULL
&& out_arch
!= NULL
)
2923 if (in_arch
!= NULL
&& out_arch
== NULL
)
2926 /* Parse subset from arch string. */
2927 if (!riscv_parse_subset (&rpe_in
, in_arch
))
2930 if (!riscv_parse_subset (&rpe_out
, out_arch
))
2933 /* Checking XLEN. */
2934 if (xlen_out
!= xlen_in
)
2937 (_("error: %pB: ISA string of input (%s) doesn't match "
2938 "output (%s)."), ibfd
, in_arch
, out_arch
);
2942 /* Merge subset list. */
2943 in
= in_subsets
.head
;
2944 out
= out_subsets
.head
;
2946 /* Merge standard extension. */
2947 if (!riscv_merge_std_ext (ibfd
, in_arch
, out_arch
, &in
, &out
))
2950 /* Merge all non-single letter extensions with single call. */
2951 if (!riscv_merge_multi_letter_ext (ibfd
, &in
, &out
))
2954 if (xlen_in
!= xlen_out
)
2957 (_("error: %pB: XLEN of input (%u) doesn't match "
2958 "output (%u)."), ibfd
, xlen_in
, xlen_out
);
2962 if (xlen_in
!= ARCH_SIZE
)
2965 (_("error: %pB: Unsupported XLEN (%u), you might be "
2966 "using wrong emulation."), ibfd
, xlen_in
);
2970 merged_arch_str
= riscv_arch_str (ARCH_SIZE
, &merged_subsets
);
2972 /* Release the subset lists. */
2973 riscv_release_subset_list (&in_subsets
);
2974 riscv_release_subset_list (&out_subsets
);
2975 riscv_release_subset_list (&merged_subsets
);
2977 return merged_arch_str
;
2980 /* Merge object attributes from IBFD into output_bfd of INFO.
2981 Raise an error if there are conflicting attributes. */
2984 riscv_merge_attributes (bfd
*ibfd
, struct bfd_link_info
*info
)
2986 bfd
*obfd
= info
->output_bfd
;
2987 obj_attribute
*in_attr
;
2988 obj_attribute
*out_attr
;
2989 bfd_boolean result
= TRUE
;
2990 bfd_boolean priv_attrs_merged
= FALSE
;
2991 const char *sec_name
= get_elf_backend_data (ibfd
)->obj_attrs_section
;
2994 /* Skip linker created files. */
2995 if (ibfd
->flags
& BFD_LINKER_CREATED
)
2998 /* Skip any input that doesn't have an attribute section.
2999 This enables to link object files without attribute section with
3001 if (bfd_get_section_by_name (ibfd
, sec_name
) == NULL
)
3004 if (!elf_known_obj_attributes_proc (obfd
)[0].i
)
3006 /* This is the first object. Copy the attributes. */
3007 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
3009 out_attr
= elf_known_obj_attributes_proc (obfd
);
3011 /* Use the Tag_null value to indicate the attributes have been
3018 in_attr
= elf_known_obj_attributes_proc (ibfd
);
3019 out_attr
= elf_known_obj_attributes_proc (obfd
);
3021 for (i
= LEAST_KNOWN_OBJ_ATTRIBUTE
; i
< NUM_KNOWN_OBJ_ATTRIBUTES
; i
++)
3025 case Tag_RISCV_arch
:
3026 if (!out_attr
[Tag_RISCV_arch
].s
)
3027 out_attr
[Tag_RISCV_arch
].s
= in_attr
[Tag_RISCV_arch
].s
;
3028 else if (in_attr
[Tag_RISCV_arch
].s
3029 && out_attr
[Tag_RISCV_arch
].s
)
3031 /* Check arch compatible. */
3033 riscv_merge_arch_attr_info (ibfd
,
3034 in_attr
[Tag_RISCV_arch
].s
,
3035 out_attr
[Tag_RISCV_arch
].s
);
3036 if (merged_arch
== NULL
)
3039 out_attr
[Tag_RISCV_arch
].s
= "";
3042 out_attr
[Tag_RISCV_arch
].s
= merged_arch
;
3046 case Tag_RISCV_priv_spec
:
3047 case Tag_RISCV_priv_spec_minor
:
3048 case Tag_RISCV_priv_spec_revision
:
3049 /* If we have handled the priv attributes, then skip it. */
3050 if (!priv_attrs_merged
)
3052 unsigned int Tag_a
= Tag_RISCV_priv_spec
;
3053 unsigned int Tag_b
= Tag_RISCV_priv_spec_minor
;
3054 unsigned int Tag_c
= Tag_RISCV_priv_spec_revision
;
3055 enum riscv_priv_spec_class in_priv_spec
;
3056 enum riscv_priv_spec_class out_priv_spec
;
3058 /* Get the priv spec class from elf attribute numbers. */
3059 riscv_get_priv_spec_class_from_numbers (in_attr
[Tag_a
].i
,
3063 riscv_get_priv_spec_class_from_numbers (out_attr
[Tag_a
].i
,
3068 /* Allow to link the object without the priv specs. */
3069 if (out_priv_spec
== PRIV_SPEC_CLASS_NONE
)
3071 out_attr
[Tag_a
].i
= in_attr
[Tag_a
].i
;
3072 out_attr
[Tag_b
].i
= in_attr
[Tag_b
].i
;
3073 out_attr
[Tag_c
].i
= in_attr
[Tag_c
].i
;
3075 else if (in_priv_spec
!= PRIV_SPEC_CLASS_NONE
3076 && in_priv_spec
!= out_priv_spec
)
3079 (_("warning: %pB use privilege spec version %u.%u.%u but "
3080 "the output use version %u.%u.%u."),
3089 /* The priv spec v1.9.1 can be linked with other spec
3090 versions since the conflicts. We plan to drop the
3091 v1.9.1 in a year or two, so this confict should be
3092 removed in the future. */
3093 if (in_priv_spec
== PRIV_SPEC_CLASS_1P9P1
3094 || out_priv_spec
== PRIV_SPEC_CLASS_1P9P1
)
3097 (_("warning: privilege spec version 1.9.1 can not be "
3098 "linked with other spec versions."));
3101 /* Update the output priv attributes to the newest. */
3102 if (in_priv_spec
> out_priv_spec
)
3104 out_attr
[Tag_a
].i
= in_attr
[Tag_a
].i
;
3105 out_attr
[Tag_b
].i
= in_attr
[Tag_b
].i
;
3106 out_attr
[Tag_c
].i
= in_attr
[Tag_c
].i
;
3109 priv_attrs_merged
= TRUE
;
3113 case Tag_RISCV_unaligned_access
:
3114 out_attr
[i
].i
|= in_attr
[i
].i
;
3117 case Tag_RISCV_stack_align
:
3118 if (out_attr
[i
].i
== 0)
3119 out_attr
[i
].i
= in_attr
[i
].i
;
3120 else if (in_attr
[i
].i
!= 0
3121 && out_attr
[i
].i
!= 0
3122 && out_attr
[i
].i
!= in_attr
[i
].i
)
3125 (_("error: %pB use %u-byte stack aligned but the output "
3126 "use %u-byte stack aligned."),
3127 ibfd
, in_attr
[i
].i
, out_attr
[i
].i
);
3133 result
&= _bfd_elf_merge_unknown_attribute_low (ibfd
, obfd
, i
);
3136 /* If out_attr was copied from in_attr then it won't have a type yet. */
3137 if (in_attr
[i
].type
&& !out_attr
[i
].type
)
3138 out_attr
[i
].type
= in_attr
[i
].type
;
3141 /* Merge Tag_compatibility attributes and any common GNU ones. */
3142 if (!_bfd_elf_merge_object_attributes (ibfd
, info
))
3145 /* Check for any attributes not known on RISC-V. */
3146 result
&= _bfd_elf_merge_unknown_attribute_list (ibfd
, obfd
);
3151 /* Merge backend specific data from an object file to the output
3152 object file when linking. */
3155 _bfd_riscv_elf_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
3157 bfd
*obfd
= info
->output_bfd
;
3158 flagword new_flags
, old_flags
;
3160 if (!is_riscv_elf (ibfd
) || !is_riscv_elf (obfd
))
3163 if (strcmp (bfd_get_target (ibfd
), bfd_get_target (obfd
)) != 0)
3165 (*_bfd_error_handler
)
3166 (_("%pB: ABI is incompatible with that of the selected emulation:\n"
3167 " target emulation `%s' does not match `%s'"),
3168 ibfd
, bfd_get_target (ibfd
), bfd_get_target (obfd
));
3172 if (!_bfd_elf_merge_object_attributes (ibfd
, info
))
3175 if (!riscv_merge_attributes (ibfd
, info
))
3178 new_flags
= elf_elfheader (ibfd
)->e_flags
;
3179 old_flags
= elf_elfheader (obfd
)->e_flags
;
3181 if (! elf_flags_init (obfd
))
3183 elf_flags_init (obfd
) = TRUE
;
3184 elf_elfheader (obfd
)->e_flags
= new_flags
;
3188 /* Check to see if the input BFD actually contains any sections. If not,
3189 its flags may not have been initialized either, but it cannot actually
3190 cause any incompatibility. Do not short-circuit dynamic objects; their
3191 section list may be emptied by elf_link_add_object_symbols.
3193 Also check to see if there are no code sections in the input. In this
3194 case, there is no need to check for code specific flags. */
3195 if (!(ibfd
->flags
& DYNAMIC
))
3197 bfd_boolean null_input_bfd
= TRUE
;
3198 bfd_boolean only_data_sections
= TRUE
;
3201 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
3203 if ((bfd_section_flags (sec
)
3204 & (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
3205 == (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
3206 only_data_sections
= FALSE
;
3208 null_input_bfd
= FALSE
;
3212 if (null_input_bfd
|| only_data_sections
)
3216 /* Disallow linking different float ABIs. */
3217 if ((old_flags
^ new_flags
) & EF_RISCV_FLOAT_ABI
)
3219 (*_bfd_error_handler
)
3220 (_("%pB: can't link %s modules with %s modules"), ibfd
,
3221 riscv_float_abi_string (new_flags
),
3222 riscv_float_abi_string (old_flags
));
3226 /* Disallow linking RVE and non-RVE. */
3227 if ((old_flags
^ new_flags
) & EF_RISCV_RVE
)
3229 (*_bfd_error_handler
)
3230 (_("%pB: can't link RVE with other target"), ibfd
);
3234 /* Allow linking RVC and non-RVC, and keep the RVC flag. */
3235 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_RISCV_RVC
;
3240 bfd_set_error (bfd_error_bad_value
);
3244 /* Delete some bytes from a section while relaxing. */
3247 riscv_relax_delete_bytes (bfd
*abfd
, asection
*sec
, bfd_vma addr
, size_t count
,
3248 struct bfd_link_info
*link_info
)
3250 unsigned int i
, symcount
;
3251 bfd_vma toaddr
= sec
->size
;
3252 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (abfd
);
3253 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3254 unsigned int sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
3255 struct bfd_elf_section_data
*data
= elf_section_data (sec
);
3256 bfd_byte
*contents
= data
->this_hdr
.contents
;
3258 /* Actually delete the bytes. */
3260 memmove (contents
+ addr
, contents
+ addr
+ count
, toaddr
- addr
- count
);
3262 /* Adjust the location of all of the relocs. Note that we need not
3263 adjust the addends, since all PC-relative references must be against
3264 symbols, which we will adjust below. */
3265 for (i
= 0; i
< sec
->reloc_count
; i
++)
3266 if (data
->relocs
[i
].r_offset
> addr
&& data
->relocs
[i
].r_offset
< toaddr
)
3267 data
->relocs
[i
].r_offset
-= count
;
3269 /* Adjust the local symbols defined in this section. */
3270 for (i
= 0; i
< symtab_hdr
->sh_info
; i
++)
3272 Elf_Internal_Sym
*sym
= (Elf_Internal_Sym
*) symtab_hdr
->contents
+ i
;
3273 if (sym
->st_shndx
== sec_shndx
)
3275 /* If the symbol is in the range of memory we just moved, we
3276 have to adjust its value. */
3277 if (sym
->st_value
> addr
&& sym
->st_value
<= toaddr
)
3278 sym
->st_value
-= count
;
3280 /* If the symbol *spans* the bytes we just deleted (i.e. its
3281 *end* is in the moved bytes but its *start* isn't), then we
3282 must adjust its size.
3284 This test needs to use the original value of st_value, otherwise
3285 we might accidentally decrease size when deleting bytes right
3286 before the symbol. But since deleted relocs can't span across
3287 symbols, we can't have both a st_value and a st_size decrease,
3288 so it is simpler to just use an else. */
3289 else if (sym
->st_value
<= addr
3290 && sym
->st_value
+ sym
->st_size
> addr
3291 && sym
->st_value
+ sym
->st_size
<= toaddr
)
3292 sym
->st_size
-= count
;
3296 /* Now adjust the global symbols defined in this section. */
3297 symcount
= ((symtab_hdr
->sh_size
/ sizeof (ElfNN_External_Sym
))
3298 - symtab_hdr
->sh_info
);
3300 for (i
= 0; i
< symcount
; i
++)
3302 struct elf_link_hash_entry
*sym_hash
= sym_hashes
[i
];
3304 /* The '--wrap SYMBOL' option is causing a pain when the object file,
3305 containing the definition of __wrap_SYMBOL, includes a direct
3306 call to SYMBOL as well. Since both __wrap_SYMBOL and SYMBOL reference
3307 the same symbol (which is __wrap_SYMBOL), but still exist as two
3308 different symbols in 'sym_hashes', we don't want to adjust
3309 the global symbol __wrap_SYMBOL twice. */
3310 /* The same problem occurs with symbols that are versioned_hidden, as
3311 foo becomes an alias for foo@BAR, and hence they need the same
3313 if (link_info
->wrap_hash
!= NULL
3314 || sym_hash
->versioned
== versioned_hidden
)
3316 struct elf_link_hash_entry
**cur_sym_hashes
;
3318 /* Loop only over the symbols which have already been checked. */
3319 for (cur_sym_hashes
= sym_hashes
; cur_sym_hashes
< &sym_hashes
[i
];
3322 /* If the current symbol is identical to 'sym_hash', that means
3323 the symbol was already adjusted (or at least checked). */
3324 if (*cur_sym_hashes
== sym_hash
)
3327 /* Don't adjust the symbol again. */
3328 if (cur_sym_hashes
< &sym_hashes
[i
])
3332 if ((sym_hash
->root
.type
== bfd_link_hash_defined
3333 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
3334 && sym_hash
->root
.u
.def
.section
== sec
)
3336 /* As above, adjust the value if needed. */
3337 if (sym_hash
->root
.u
.def
.value
> addr
3338 && sym_hash
->root
.u
.def
.value
<= toaddr
)
3339 sym_hash
->root
.u
.def
.value
-= count
;
3341 /* As above, adjust the size if needed. */
3342 else if (sym_hash
->root
.u
.def
.value
<= addr
3343 && sym_hash
->root
.u
.def
.value
+ sym_hash
->size
> addr
3344 && sym_hash
->root
.u
.def
.value
+ sym_hash
->size
<= toaddr
)
3345 sym_hash
->size
-= count
;
3352 /* A second format for recording PC-relative hi relocations. This stores the
3353 information required to relax them to GP-relative addresses. */
3355 typedef struct riscv_pcgp_hi_reloc riscv_pcgp_hi_reloc
;
3356 struct riscv_pcgp_hi_reloc
3363 bfd_boolean undefined_weak
;
3364 riscv_pcgp_hi_reloc
*next
;
3367 typedef struct riscv_pcgp_lo_reloc riscv_pcgp_lo_reloc
;
3368 struct riscv_pcgp_lo_reloc
3371 riscv_pcgp_lo_reloc
*next
;
3376 riscv_pcgp_hi_reloc
*hi
;
3377 riscv_pcgp_lo_reloc
*lo
;
3378 } riscv_pcgp_relocs
;
3380 /* Initialize the pcgp reloc info in P. */
3383 riscv_init_pcgp_relocs (riscv_pcgp_relocs
*p
)
3390 /* Free the pcgp reloc info in P. */
3393 riscv_free_pcgp_relocs (riscv_pcgp_relocs
*p
,
3394 bfd
*abfd ATTRIBUTE_UNUSED
,
3395 asection
*sec ATTRIBUTE_UNUSED
)
3397 riscv_pcgp_hi_reloc
*c
;
3398 riscv_pcgp_lo_reloc
*l
;
3400 for (c
= p
->hi
; c
!= NULL
;)
3402 riscv_pcgp_hi_reloc
*next
= c
->next
;
3407 for (l
= p
->lo
; l
!= NULL
;)
3409 riscv_pcgp_lo_reloc
*next
= l
->next
;
3415 /* Record pcgp hi part reloc info in P, using HI_SEC_OFF as the lookup index.
3416 The HI_ADDEND, HI_ADDR, HI_SYM, and SYM_SEC args contain info required to
3417 relax the corresponding lo part reloc. */
3420 riscv_record_pcgp_hi_reloc (riscv_pcgp_relocs
*p
, bfd_vma hi_sec_off
,
3421 bfd_vma hi_addend
, bfd_vma hi_addr
,
3422 unsigned hi_sym
, asection
*sym_sec
,
3423 bfd_boolean undefined_weak
)
3425 riscv_pcgp_hi_reloc
*new = bfd_malloc (sizeof(*new));
3428 new->hi_sec_off
= hi_sec_off
;
3429 new->hi_addend
= hi_addend
;
3430 new->hi_addr
= hi_addr
;
3431 new->hi_sym
= hi_sym
;
3432 new->sym_sec
= sym_sec
;
3433 new->undefined_weak
= undefined_weak
;
3439 /* Look up hi part pcgp reloc info in P, using HI_SEC_OFF as the lookup index.
3440 This is used by a lo part reloc to find the corresponding hi part reloc. */
3442 static riscv_pcgp_hi_reloc
*
3443 riscv_find_pcgp_hi_reloc(riscv_pcgp_relocs
*p
, bfd_vma hi_sec_off
)
3445 riscv_pcgp_hi_reloc
*c
;
3447 for (c
= p
->hi
; c
!= NULL
; c
= c
->next
)
3448 if (c
->hi_sec_off
== hi_sec_off
)
3453 /* Record pcgp lo part reloc info in P, using HI_SEC_OFF as the lookup info.
3454 This is used to record relocs that can't be relaxed. */
3457 riscv_record_pcgp_lo_reloc (riscv_pcgp_relocs
*p
, bfd_vma hi_sec_off
)
3459 riscv_pcgp_lo_reloc
*new = bfd_malloc (sizeof(*new));
3462 new->hi_sec_off
= hi_sec_off
;
3468 /* Look up lo part pcgp reloc info in P, using HI_SEC_OFF as the lookup index.
3469 This is used by a hi part reloc to find the corresponding lo part reloc. */
3472 riscv_find_pcgp_lo_reloc (riscv_pcgp_relocs
*p
, bfd_vma hi_sec_off
)
3474 riscv_pcgp_lo_reloc
*c
;
3476 for (c
= p
->lo
; c
!= NULL
; c
= c
->next
)
3477 if (c
->hi_sec_off
== hi_sec_off
)
3482 typedef bfd_boolean (*relax_func_t
) (bfd
*, asection
*, asection
*,
3483 struct bfd_link_info
*,
3484 Elf_Internal_Rela
*,
3485 bfd_vma
, bfd_vma
, bfd_vma
, bfd_boolean
*,
3486 riscv_pcgp_relocs
*,
3487 bfd_boolean undefined_weak
);
3489 /* Relax AUIPC + JALR into JAL. */
3492 _bfd_riscv_relax_call (bfd
*abfd
, asection
*sec
, asection
*sym_sec
,
3493 struct bfd_link_info
*link_info
,
3494 Elf_Internal_Rela
*rel
,
3496 bfd_vma max_alignment
,
3497 bfd_vma reserve_size ATTRIBUTE_UNUSED
,
3499 riscv_pcgp_relocs
*pcgp_relocs ATTRIBUTE_UNUSED
,
3500 bfd_boolean undefined_weak ATTRIBUTE_UNUSED
)
3502 bfd_byte
*contents
= elf_section_data (sec
)->this_hdr
.contents
;
3503 bfd_signed_vma foff
= symval
- (sec_addr (sec
) + rel
->r_offset
);
3504 bfd_boolean near_zero
= (symval
+ RISCV_IMM_REACH
/2) < RISCV_IMM_REACH
;
3505 bfd_vma auipc
, jalr
;
3506 int rd
, r_type
, len
= 4, rvc
= elf_elfheader (abfd
)->e_flags
& EF_RISCV_RVC
;
3508 /* If the call crosses section boundaries, an alignment directive could
3509 cause the PC-relative offset to later increase, so we need to add in the
3510 max alignment of any section inclusive from the call to the target.
3511 Otherwise, we only need to use the alignment of the current section. */
3512 if (VALID_UJTYPE_IMM (foff
))
3514 if (sym_sec
->output_section
== sec
->output_section
3515 && sym_sec
->output_section
!= bfd_abs_section_ptr
)
3516 max_alignment
= (bfd_vma
) 1 << sym_sec
->output_section
->alignment_power
;
3517 foff
+= (foff
< 0 ? -max_alignment
: max_alignment
);
3520 /* See if this function call can be shortened. */
3521 if (!VALID_UJTYPE_IMM (foff
) && !(!bfd_link_pic (link_info
) && near_zero
))
3524 /* Shorten the function call. */
3525 BFD_ASSERT (rel
->r_offset
+ 8 <= sec
->size
);
3527 auipc
= bfd_get_32 (abfd
, contents
+ rel
->r_offset
);
3528 jalr
= bfd_get_32 (abfd
, contents
+ rel
->r_offset
+ 4);
3529 rd
= (jalr
>> OP_SH_RD
) & OP_MASK_RD
;
3530 rvc
= rvc
&& VALID_RVC_J_IMM (foff
);
3532 /* C.J exists on RV32 and RV64, but C.JAL is RV32-only. */
3533 rvc
= rvc
&& (rd
== 0 || (rd
== X_RA
&& ARCH_SIZE
== 32));
3537 /* Relax to C.J[AL] rd, addr. */
3538 r_type
= R_RISCV_RVC_JUMP
;
3539 auipc
= rd
== 0 ? MATCH_C_J
: MATCH_C_JAL
;
3542 else if (VALID_UJTYPE_IMM (foff
))
3544 /* Relax to JAL rd, addr. */
3545 r_type
= R_RISCV_JAL
;
3546 auipc
= MATCH_JAL
| (rd
<< OP_SH_RD
);
3548 else /* near_zero */
3550 /* Relax to JALR rd, x0, addr. */
3551 r_type
= R_RISCV_LO12_I
;
3552 auipc
= MATCH_JALR
| (rd
<< OP_SH_RD
);
3555 /* Replace the R_RISCV_CALL reloc. */
3556 rel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (rel
->r_info
), r_type
);
3557 /* Replace the AUIPC. */
3558 bfd_put (8 * len
, abfd
, auipc
, contents
+ rel
->r_offset
);
3560 /* Delete unnecessary JALR. */
3562 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
+ len
, 8 - len
,
3566 /* Traverse all output sections and return the max alignment. */
3569 _bfd_riscv_get_max_alignment (asection
*sec
)
3571 unsigned int max_alignment_power
= 0;
3574 for (o
= sec
->output_section
->owner
->sections
; o
!= NULL
; o
= o
->next
)
3576 if (o
->alignment_power
> max_alignment_power
)
3577 max_alignment_power
= o
->alignment_power
;
3580 return (bfd_vma
) 1 << max_alignment_power
;
3583 /* Relax non-PIC global variable references. */
3586 _bfd_riscv_relax_lui (bfd
*abfd
,
3589 struct bfd_link_info
*link_info
,
3590 Elf_Internal_Rela
*rel
,
3592 bfd_vma max_alignment
,
3593 bfd_vma reserve_size
,
3595 riscv_pcgp_relocs
*pcgp_relocs ATTRIBUTE_UNUSED
,
3596 bfd_boolean undefined_weak
)
3598 bfd_byte
*contents
= elf_section_data (sec
)->this_hdr
.contents
;
3599 bfd_vma gp
= riscv_global_pointer_value (link_info
);
3600 int use_rvc
= elf_elfheader (abfd
)->e_flags
& EF_RISCV_RVC
;
3602 BFD_ASSERT (rel
->r_offset
+ 4 <= sec
->size
);
3606 /* If gp and the symbol are in the same output section, which is not the
3607 abs section, then consider only that output section's alignment. */
3608 struct bfd_link_hash_entry
*h
=
3609 bfd_link_hash_lookup (link_info
->hash
, RISCV_GP_SYMBOL
, FALSE
, FALSE
,
3611 if (h
->u
.def
.section
->output_section
== sym_sec
->output_section
3612 && sym_sec
->output_section
!= bfd_abs_section_ptr
)
3613 max_alignment
= (bfd_vma
) 1 << sym_sec
->output_section
->alignment_power
;
3616 /* Is the reference in range of x0 or gp?
3617 Valid gp range conservatively because of alignment issue. */
3619 || (VALID_ITYPE_IMM (symval
)
3621 && VALID_ITYPE_IMM (symval
- gp
+ max_alignment
+ reserve_size
))
3623 && VALID_ITYPE_IMM (symval
- gp
- max_alignment
- reserve_size
))))
3625 unsigned sym
= ELFNN_R_SYM (rel
->r_info
);
3626 switch (ELFNN_R_TYPE (rel
->r_info
))
3628 case R_RISCV_LO12_I
:
3631 /* Change the RS1 to zero. */
3632 bfd_vma insn
= bfd_get_32 (abfd
, contents
+ rel
->r_offset
);
3633 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
3634 bfd_put_32 (abfd
, insn
, contents
+ rel
->r_offset
);
3637 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_GPREL_I
);
3640 case R_RISCV_LO12_S
:
3643 /* Change the RS1 to zero. */
3644 bfd_vma insn
= bfd_get_32 (abfd
, contents
+ rel
->r_offset
);
3645 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
3646 bfd_put_32 (abfd
, insn
, contents
+ rel
->r_offset
);
3649 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_GPREL_S
);
3653 /* We can delete the unnecessary LUI and reloc. */
3654 rel
->r_info
= ELFNN_R_INFO (0, R_RISCV_NONE
);
3656 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
, 4,
3664 /* Can we relax LUI to C.LUI? Alignment might move the section forward;
3665 account for this assuming page alignment at worst. In the presence of
3666 RELRO segment the linker aligns it by one page size, therefore sections
3667 after the segment can be moved more than one page. */
3670 && ELFNN_R_TYPE (rel
->r_info
) == R_RISCV_HI20
3671 && VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (symval
))
3672 && VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (symval
)
3673 + (link_info
->relro
? 2 * ELF_MAXPAGESIZE
3674 : ELF_MAXPAGESIZE
)))
3676 /* Replace LUI with C.LUI if legal (i.e., rd != x0 and rd != x2/sp). */
3677 bfd_vma lui
= bfd_get_32 (abfd
, contents
+ rel
->r_offset
);
3678 unsigned rd
= ((unsigned)lui
>> OP_SH_RD
) & OP_MASK_RD
;
3679 if (rd
== 0 || rd
== X_SP
)
3682 lui
= (lui
& (OP_MASK_RD
<< OP_SH_RD
)) | MATCH_C_LUI
;
3683 bfd_put_32 (abfd
, lui
, contents
+ rel
->r_offset
);
3685 /* Replace the R_RISCV_HI20 reloc. */
3686 rel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (rel
->r_info
), R_RISCV_RVC_LUI
);
3689 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
+ 2, 2,
3696 /* Relax non-PIC TLS references. */
3699 _bfd_riscv_relax_tls_le (bfd
*abfd
,
3701 asection
*sym_sec ATTRIBUTE_UNUSED
,
3702 struct bfd_link_info
*link_info
,
3703 Elf_Internal_Rela
*rel
,
3705 bfd_vma max_alignment ATTRIBUTE_UNUSED
,
3706 bfd_vma reserve_size ATTRIBUTE_UNUSED
,
3708 riscv_pcgp_relocs
*prcel_relocs ATTRIBUTE_UNUSED
,
3709 bfd_boolean undefined_weak ATTRIBUTE_UNUSED
)
3711 /* See if this symbol is in range of tp. */
3712 if (RISCV_CONST_HIGH_PART (tpoff (link_info
, symval
)) != 0)
3715 BFD_ASSERT (rel
->r_offset
+ 4 <= sec
->size
);
3716 switch (ELFNN_R_TYPE (rel
->r_info
))
3718 case R_RISCV_TPREL_LO12_I
:
3719 rel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (rel
->r_info
), R_RISCV_TPREL_I
);
3722 case R_RISCV_TPREL_LO12_S
:
3723 rel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (rel
->r_info
), R_RISCV_TPREL_S
);
3726 case R_RISCV_TPREL_HI20
:
3727 case R_RISCV_TPREL_ADD
:
3728 /* We can delete the unnecessary instruction and reloc. */
3729 rel
->r_info
= ELFNN_R_INFO (0, R_RISCV_NONE
);
3731 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
, 4, link_info
);
3738 /* Implement R_RISCV_ALIGN by deleting excess alignment NOPs. */
3741 _bfd_riscv_relax_align (bfd
*abfd
, asection
*sec
,
3743 struct bfd_link_info
*link_info
,
3744 Elf_Internal_Rela
*rel
,
3746 bfd_vma max_alignment ATTRIBUTE_UNUSED
,
3747 bfd_vma reserve_size ATTRIBUTE_UNUSED
,
3748 bfd_boolean
*again ATTRIBUTE_UNUSED
,
3749 riscv_pcgp_relocs
*pcrel_relocs ATTRIBUTE_UNUSED
,
3750 bfd_boolean undefined_weak ATTRIBUTE_UNUSED
)
3752 bfd_byte
*contents
= elf_section_data (sec
)->this_hdr
.contents
;
3753 bfd_vma alignment
= 1, pos
;
3754 while (alignment
<= rel
->r_addend
)
3757 symval
-= rel
->r_addend
;
3758 bfd_vma aligned_addr
= ((symval
- 1) & ~(alignment
- 1)) + alignment
;
3759 bfd_vma nop_bytes
= aligned_addr
- symval
;
3761 /* Once we've handled an R_RISCV_ALIGN, we can't relax anything else. */
3762 sec
->sec_flg0
= TRUE
;
3764 /* Make sure there are enough NOPs to actually achieve the alignment. */
3765 if (rel
->r_addend
< nop_bytes
)
3768 (_("%pB(%pA+%#" PRIx64
"): %" PRId64
" bytes required for alignment "
3769 "to %" PRId64
"-byte boundary, but only %" PRId64
" present"),
3770 abfd
, sym_sec
, (uint64_t) rel
->r_offset
,
3771 (int64_t) nop_bytes
, (int64_t) alignment
, (int64_t) rel
->r_addend
);
3772 bfd_set_error (bfd_error_bad_value
);
3776 /* Delete the reloc. */
3777 rel
->r_info
= ELFNN_R_INFO (0, R_RISCV_NONE
);
3779 /* If the number of NOPs is already correct, there's nothing to do. */
3780 if (nop_bytes
== rel
->r_addend
)
3783 /* Write as many RISC-V NOPs as we need. */
3784 for (pos
= 0; pos
< (nop_bytes
& -4); pos
+= 4)
3785 bfd_put_32 (abfd
, RISCV_NOP
, contents
+ rel
->r_offset
+ pos
);
3787 /* Write a final RVC NOP if need be. */
3788 if (nop_bytes
% 4 != 0)
3789 bfd_put_16 (abfd
, RVC_NOP
, contents
+ rel
->r_offset
+ pos
);
3791 /* Delete the excess bytes. */
3792 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
+ nop_bytes
,
3793 rel
->r_addend
- nop_bytes
, link_info
);
3796 /* Relax PC-relative references to GP-relative references. */
3799 _bfd_riscv_relax_pc (bfd
*abfd ATTRIBUTE_UNUSED
,
3802 struct bfd_link_info
*link_info
,
3803 Elf_Internal_Rela
*rel
,
3805 bfd_vma max_alignment
,
3806 bfd_vma reserve_size
,
3807 bfd_boolean
*again ATTRIBUTE_UNUSED
,
3808 riscv_pcgp_relocs
*pcgp_relocs
,
3809 bfd_boolean undefined_weak
)
3811 bfd_byte
*contents
= elf_section_data (sec
)->this_hdr
.contents
;
3812 bfd_vma gp
= riscv_global_pointer_value (link_info
);
3814 BFD_ASSERT (rel
->r_offset
+ 4 <= sec
->size
);
3816 /* Chain the _LO relocs to their cooresponding _HI reloc to compute the
3817 * actual target address. */
3818 riscv_pcgp_hi_reloc hi_reloc
;
3819 memset (&hi_reloc
, 0, sizeof (hi_reloc
));
3820 switch (ELFNN_R_TYPE (rel
->r_info
))
3822 case R_RISCV_PCREL_LO12_I
:
3823 case R_RISCV_PCREL_LO12_S
:
3825 /* If the %lo has an addend, it isn't for the label pointing at the
3826 hi part instruction, but rather for the symbol pointed at by the
3827 hi part instruction. So we must subtract it here for the lookup.
3828 It is still used below in the final symbol address. */
3829 bfd_vma hi_sec_off
= symval
- sec_addr (sym_sec
) - rel
->r_addend
;
3830 riscv_pcgp_hi_reloc
*hi
= riscv_find_pcgp_hi_reloc (pcgp_relocs
,
3834 riscv_record_pcgp_lo_reloc (pcgp_relocs
, hi_sec_off
);
3839 symval
= hi_reloc
.hi_addr
;
3840 sym_sec
= hi_reloc
.sym_sec
;
3842 /* We can not know whether the undefined weak symbol is referenced
3843 according to the information of R_RISCV_PCREL_LO12_I/S. Therefore,
3844 we have to record the 'undefined_weak' flag when handling the
3845 corresponding R_RISCV_HI20 reloc in riscv_record_pcgp_hi_reloc. */
3846 undefined_weak
= hi_reloc
.undefined_weak
;
3850 case R_RISCV_PCREL_HI20
:
3851 /* Mergeable symbols and code might later move out of range. */
3852 if (! undefined_weak
3853 && sym_sec
->flags
& (SEC_MERGE
| SEC_CODE
))
3856 /* If the cooresponding lo relocation has already been seen then it's not
3857 * safe to relax this relocation. */
3858 if (riscv_find_pcgp_lo_reloc (pcgp_relocs
, rel
->r_offset
))
3869 /* If gp and the symbol are in the same output section, which is not the
3870 abs section, then consider only that output section's alignment. */
3871 struct bfd_link_hash_entry
*h
=
3872 bfd_link_hash_lookup (link_info
->hash
, RISCV_GP_SYMBOL
, FALSE
, FALSE
,
3874 if (h
->u
.def
.section
->output_section
== sym_sec
->output_section
3875 && sym_sec
->output_section
!= bfd_abs_section_ptr
)
3876 max_alignment
= (bfd_vma
) 1 << sym_sec
->output_section
->alignment_power
;
3879 /* Is the reference in range of x0 or gp?
3880 Valid gp range conservatively because of alignment issue. */
3882 || (VALID_ITYPE_IMM (symval
)
3884 && VALID_ITYPE_IMM (symval
- gp
+ max_alignment
+ reserve_size
))
3886 && VALID_ITYPE_IMM (symval
- gp
- max_alignment
- reserve_size
))))
3888 unsigned sym
= hi_reloc
.hi_sym
;
3889 switch (ELFNN_R_TYPE (rel
->r_info
))
3891 case R_RISCV_PCREL_LO12_I
:
3894 /* Change the RS1 to zero, and then modify the relocation
3895 type to R_RISCV_LO12_I. */
3896 bfd_vma insn
= bfd_get_32 (abfd
, contents
+ rel
->r_offset
);
3897 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
3898 bfd_put_32 (abfd
, insn
, contents
+ rel
->r_offset
);
3899 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_LO12_I
);
3900 rel
->r_addend
= hi_reloc
.hi_addend
;
3904 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_GPREL_I
);
3905 rel
->r_addend
+= hi_reloc
.hi_addend
;
3909 case R_RISCV_PCREL_LO12_S
:
3912 /* Change the RS1 to zero, and then modify the relocation
3913 type to R_RISCV_LO12_S. */
3914 bfd_vma insn
= bfd_get_32 (abfd
, contents
+ rel
->r_offset
);
3915 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
3916 bfd_put_32 (abfd
, insn
, contents
+ rel
->r_offset
);
3917 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_LO12_S
);
3918 rel
->r_addend
= hi_reloc
.hi_addend
;
3922 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_GPREL_S
);
3923 rel
->r_addend
+= hi_reloc
.hi_addend
;
3927 case R_RISCV_PCREL_HI20
:
3928 riscv_record_pcgp_hi_reloc (pcgp_relocs
,
3932 ELFNN_R_SYM(rel
->r_info
),
3935 /* We can delete the unnecessary AUIPC and reloc. */
3936 rel
->r_info
= ELFNN_R_INFO (0, R_RISCV_DELETE
);
3948 /* Relax PC-relative references to GP-relative references. */
3951 _bfd_riscv_relax_delete (bfd
*abfd
,
3953 asection
*sym_sec ATTRIBUTE_UNUSED
,
3954 struct bfd_link_info
*link_info
,
3955 Elf_Internal_Rela
*rel
,
3956 bfd_vma symval ATTRIBUTE_UNUSED
,
3957 bfd_vma max_alignment ATTRIBUTE_UNUSED
,
3958 bfd_vma reserve_size ATTRIBUTE_UNUSED
,
3959 bfd_boolean
*again ATTRIBUTE_UNUSED
,
3960 riscv_pcgp_relocs
*pcgp_relocs ATTRIBUTE_UNUSED
,
3961 bfd_boolean undefined_weak ATTRIBUTE_UNUSED
)
3963 if (!riscv_relax_delete_bytes(abfd
, sec
, rel
->r_offset
, rel
->r_addend
,
3966 rel
->r_info
= ELFNN_R_INFO(0, R_RISCV_NONE
);
3970 /* Relax a section. Pass 0 shortens code sequences unless disabled. Pass 1
3971 deletes the bytes that pass 0 made obselete. Pass 2, which cannot be
3972 disabled, handles code alignment directives. */
3975 _bfd_riscv_relax_section (bfd
*abfd
, asection
*sec
,
3976 struct bfd_link_info
*info
,
3979 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (abfd
);
3980 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
3981 struct bfd_elf_section_data
*data
= elf_section_data (sec
);
3982 Elf_Internal_Rela
*relocs
;
3983 bfd_boolean ret
= FALSE
;
3985 bfd_vma max_alignment
, reserve_size
= 0;
3986 riscv_pcgp_relocs pcgp_relocs
;
3990 if (bfd_link_relocatable (info
)
3992 || (sec
->flags
& SEC_RELOC
) == 0
3993 || sec
->reloc_count
== 0
3994 || (info
->disable_target_specific_optimizations
3995 && info
->relax_pass
== 0))
3998 riscv_init_pcgp_relocs (&pcgp_relocs
);
4000 /* Read this BFD's relocs if we haven't done so already. */
4002 relocs
= data
->relocs
;
4003 else if (!(relocs
= _bfd_elf_link_read_relocs (abfd
, sec
, NULL
, NULL
,
4004 info
->keep_memory
)))
4009 max_alignment
= htab
->max_alignment
;
4010 if (max_alignment
== (bfd_vma
) -1)
4012 max_alignment
= _bfd_riscv_get_max_alignment (sec
);
4013 htab
->max_alignment
= max_alignment
;
4017 max_alignment
= _bfd_riscv_get_max_alignment (sec
);
4019 /* Examine and consider relaxing each reloc. */
4020 for (i
= 0; i
< sec
->reloc_count
; i
++)
4023 Elf_Internal_Rela
*rel
= relocs
+ i
;
4024 relax_func_t relax_func
;
4025 int type
= ELFNN_R_TYPE (rel
->r_info
);
4028 bfd_boolean undefined_weak
= FALSE
;
4031 if (info
->relax_pass
== 0)
4033 if (type
== R_RISCV_CALL
|| type
== R_RISCV_CALL_PLT
)
4034 relax_func
= _bfd_riscv_relax_call
;
4035 else if (type
== R_RISCV_HI20
4036 || type
== R_RISCV_LO12_I
4037 || type
== R_RISCV_LO12_S
)
4038 relax_func
= _bfd_riscv_relax_lui
;
4039 else if (!bfd_link_pic(info
)
4040 && (type
== R_RISCV_PCREL_HI20
4041 || type
== R_RISCV_PCREL_LO12_I
4042 || type
== R_RISCV_PCREL_LO12_S
))
4043 relax_func
= _bfd_riscv_relax_pc
;
4044 else if (type
== R_RISCV_TPREL_HI20
4045 || type
== R_RISCV_TPREL_ADD
4046 || type
== R_RISCV_TPREL_LO12_I
4047 || type
== R_RISCV_TPREL_LO12_S
)
4048 relax_func
= _bfd_riscv_relax_tls_le
;
4052 /* Only relax this reloc if it is paired with R_RISCV_RELAX. */
4053 if (i
== sec
->reloc_count
- 1
4054 || ELFNN_R_TYPE ((rel
+ 1)->r_info
) != R_RISCV_RELAX
4055 || rel
->r_offset
!= (rel
+ 1)->r_offset
)
4058 /* Skip over the R_RISCV_RELAX. */
4061 else if (info
->relax_pass
== 1 && type
== R_RISCV_DELETE
)
4062 relax_func
= _bfd_riscv_relax_delete
;
4063 else if (info
->relax_pass
== 2 && type
== R_RISCV_ALIGN
)
4064 relax_func
= _bfd_riscv_relax_align
;
4068 data
->relocs
= relocs
;
4070 /* Read this BFD's contents if we haven't done so already. */
4071 if (!data
->this_hdr
.contents
4072 && !bfd_malloc_and_get_section (abfd
, sec
, &data
->this_hdr
.contents
))
4075 /* Read this BFD's symbols if we haven't done so already. */
4076 if (symtab_hdr
->sh_info
!= 0
4077 && !symtab_hdr
->contents
4078 && !(symtab_hdr
->contents
=
4079 (unsigned char *) bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
4080 symtab_hdr
->sh_info
,
4081 0, NULL
, NULL
, NULL
)))
4084 /* Get the value of the symbol referred to by the reloc. */
4085 if (ELFNN_R_SYM (rel
->r_info
) < symtab_hdr
->sh_info
)
4087 /* A local symbol. */
4088 Elf_Internal_Sym
*isym
= ((Elf_Internal_Sym
*) symtab_hdr
->contents
4089 + ELFNN_R_SYM (rel
->r_info
));
4090 reserve_size
= (isym
->st_size
- rel
->r_addend
) > isym
->st_size
4091 ? 0 : isym
->st_size
- rel
->r_addend
;
4093 if (isym
->st_shndx
== SHN_UNDEF
)
4094 sym_sec
= sec
, symval
= rel
->r_offset
;
4097 BFD_ASSERT (isym
->st_shndx
< elf_numsections (abfd
));
4098 sym_sec
= elf_elfsections (abfd
)[isym
->st_shndx
]->bfd_section
;
4100 /* The purpose of this code is unknown. It breaks linker scripts
4101 for embedded development that place sections at address zero.
4102 This code is believed to be unnecessary. Disabling it but not
4103 yet removing it, in case something breaks. */
4104 if (sec_addr (sym_sec
) == 0)
4107 symval
= isym
->st_value
;
4109 symtype
= ELF_ST_TYPE (isym
->st_info
);
4114 struct elf_link_hash_entry
*h
;
4116 indx
= ELFNN_R_SYM (rel
->r_info
) - symtab_hdr
->sh_info
;
4117 h
= elf_sym_hashes (abfd
)[indx
];
4119 while (h
->root
.type
== bfd_link_hash_indirect
4120 || h
->root
.type
== bfd_link_hash_warning
)
4121 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
4123 if (h
->root
.type
== bfd_link_hash_undefweak
4124 && (relax_func
== _bfd_riscv_relax_lui
4125 || relax_func
== _bfd_riscv_relax_pc
))
4127 /* For the lui and auipc relaxations, since the symbol
4128 value of an undefined weak symbol is always be zero,
4129 we can optimize the patterns into a single LI/MV/ADDI
4132 Note that, creating shared libraries and pie output may
4133 break the rule above. Fortunately, since we do not relax
4134 pc relocs when creating shared libraries and pie output,
4135 and the absolute address access for R_RISCV_HI20 isn't
4136 allowed when "-fPIC" is set, the problem of creating shared
4137 libraries can not happen currently. Once we support the
4138 auipc relaxations when creating shared libraries, then we will
4139 need the more rigorous checking for this optimization. */
4140 undefined_weak
= TRUE
;
4143 /* This line has to match the check in riscv_elf_relocate_section
4144 in the R_RISCV_CALL[_PLT] case. */
4145 if (bfd_link_pic (info
) && h
->plt
.offset
!= MINUS_ONE
)
4147 sym_sec
= htab
->elf
.splt
;
4148 symval
= h
->plt
.offset
;
4150 else if (undefined_weak
)
4153 sym_sec
= bfd_und_section_ptr
;
4155 else if ((h
->root
.type
== bfd_link_hash_defined
4156 || h
->root
.type
== bfd_link_hash_defweak
)
4157 && h
->root
.u
.def
.section
!= NULL
4158 && h
->root
.u
.def
.section
->output_section
!= NULL
)
4160 symval
= h
->root
.u
.def
.value
;
4161 sym_sec
= h
->root
.u
.def
.section
;
4166 if (h
->type
!= STT_FUNC
)
4168 (h
->size
- rel
->r_addend
) > h
->size
? 0 : h
->size
- rel
->r_addend
;
4172 if (sym_sec
->sec_info_type
== SEC_INFO_TYPE_MERGE
4173 && (sym_sec
->flags
& SEC_MERGE
))
4175 /* At this stage in linking, no SEC_MERGE symbol has been
4176 adjusted, so all references to such symbols need to be
4177 passed through _bfd_merged_section_offset. (Later, in
4178 relocate_section, all SEC_MERGE symbols *except* for
4179 section symbols have been adjusted.)
4181 gas may reduce relocations against symbols in SEC_MERGE
4182 sections to a relocation against the section symbol when
4183 the original addend was zero. When the reloc is against
4184 a section symbol we should include the addend in the
4185 offset passed to _bfd_merged_section_offset, since the
4186 location of interest is the original symbol. On the
4187 other hand, an access to "sym+addend" where "sym" is not
4188 a section symbol should not include the addend; Such an
4189 access is presumed to be an offset from "sym"; The
4190 location of interest is just "sym". */
4191 if (symtype
== STT_SECTION
)
4192 symval
+= rel
->r_addend
;
4194 symval
= _bfd_merged_section_offset (abfd
, &sym_sec
,
4195 elf_section_data (sym_sec
)->sec_info
,
4198 if (symtype
!= STT_SECTION
)
4199 symval
+= rel
->r_addend
;
4202 symval
+= rel
->r_addend
;
4204 symval
+= sec_addr (sym_sec
);
4206 if (!relax_func (abfd
, sec
, sym_sec
, info
, rel
, symval
,
4207 max_alignment
, reserve_size
, again
,
4208 &pcgp_relocs
, undefined_weak
))
4215 if (relocs
!= data
->relocs
)
4217 riscv_free_pcgp_relocs(&pcgp_relocs
, abfd
, sec
);
4223 # define PRSTATUS_SIZE 204
4224 # define PRSTATUS_OFFSET_PR_CURSIG 12
4225 # define PRSTATUS_OFFSET_PR_PID 24
4226 # define PRSTATUS_OFFSET_PR_REG 72
4227 # define ELF_GREGSET_T_SIZE 128
4228 # define PRPSINFO_SIZE 128
4229 # define PRPSINFO_OFFSET_PR_PID 16
4230 # define PRPSINFO_OFFSET_PR_FNAME 32
4231 # define PRPSINFO_OFFSET_PR_PSARGS 48
4233 # define PRSTATUS_SIZE 376
4234 # define PRSTATUS_OFFSET_PR_CURSIG 12
4235 # define PRSTATUS_OFFSET_PR_PID 32
4236 # define PRSTATUS_OFFSET_PR_REG 112
4237 # define ELF_GREGSET_T_SIZE 256
4238 # define PRPSINFO_SIZE 136
4239 # define PRPSINFO_OFFSET_PR_PID 24
4240 # define PRPSINFO_OFFSET_PR_FNAME 40
4241 # define PRPSINFO_OFFSET_PR_PSARGS 56
4244 /* Support for core dump NOTE sections. */
4247 riscv_elf_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
4249 switch (note
->descsz
)
4254 case PRSTATUS_SIZE
: /* sizeof(struct elf_prstatus) on Linux/RISC-V. */
4256 elf_tdata (abfd
)->core
->signal
4257 = bfd_get_16 (abfd
, note
->descdata
+ PRSTATUS_OFFSET_PR_CURSIG
);
4260 elf_tdata (abfd
)->core
->lwpid
4261 = bfd_get_32 (abfd
, note
->descdata
+ PRSTATUS_OFFSET_PR_PID
);
4265 /* Make a ".reg/999" section. */
4266 return _bfd_elfcore_make_pseudosection (abfd
, ".reg", ELF_GREGSET_T_SIZE
,
4267 note
->descpos
+ PRSTATUS_OFFSET_PR_REG
);
4271 riscv_elf_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
4273 switch (note
->descsz
)
4278 case PRPSINFO_SIZE
: /* sizeof(struct elf_prpsinfo) on Linux/RISC-V. */
4280 elf_tdata (abfd
)->core
->pid
4281 = bfd_get_32 (abfd
, note
->descdata
+ PRPSINFO_OFFSET_PR_PID
);
4284 elf_tdata (abfd
)->core
->program
= _bfd_elfcore_strndup
4285 (abfd
, note
->descdata
+ PRPSINFO_OFFSET_PR_FNAME
, 16);
4288 elf_tdata (abfd
)->core
->command
= _bfd_elfcore_strndup
4289 (abfd
, note
->descdata
+ PRPSINFO_OFFSET_PR_PSARGS
, 80);
4293 /* Note that for some reason, a spurious space is tacked
4294 onto the end of the args in some (at least one anyway)
4295 implementations, so strip it off if it exists. */
4298 char *command
= elf_tdata (abfd
)->core
->command
;
4299 int n
= strlen (command
);
4301 if (0 < n
&& command
[n
- 1] == ' ')
4302 command
[n
- 1] = '\0';
4308 /* Set the right mach type. */
4310 riscv_elf_object_p (bfd
*abfd
)
4312 /* There are only two mach types in RISCV currently. */
4313 if (strcmp (abfd
->xvec
->name
, "elf32-littleriscv") == 0)
4314 bfd_default_set_arch_mach (abfd
, bfd_arch_riscv
, bfd_mach_riscv32
);
4316 bfd_default_set_arch_mach (abfd
, bfd_arch_riscv
, bfd_mach_riscv64
);
4321 /* Determine whether an object attribute tag takes an integer, a
4325 riscv_elf_obj_attrs_arg_type (int tag
)
4327 return (tag
& 1) != 0 ? ATTR_TYPE_FLAG_STR_VAL
: ATTR_TYPE_FLAG_INT_VAL
;
4330 #define TARGET_LITTLE_SYM riscv_elfNN_vec
4331 #define TARGET_LITTLE_NAME "elfNN-littleriscv"
4333 #define elf_backend_reloc_type_class riscv_reloc_type_class
4335 #define bfd_elfNN_bfd_reloc_name_lookup riscv_reloc_name_lookup
4336 #define bfd_elfNN_bfd_link_hash_table_create riscv_elf_link_hash_table_create
4337 #define bfd_elfNN_bfd_reloc_type_lookup riscv_reloc_type_lookup
4338 #define bfd_elfNN_bfd_merge_private_bfd_data \
4339 _bfd_riscv_elf_merge_private_bfd_data
4341 #define elf_backend_copy_indirect_symbol riscv_elf_copy_indirect_symbol
4342 #define elf_backend_create_dynamic_sections riscv_elf_create_dynamic_sections
4343 #define elf_backend_check_relocs riscv_elf_check_relocs
4344 #define elf_backend_adjust_dynamic_symbol riscv_elf_adjust_dynamic_symbol
4345 #define elf_backend_size_dynamic_sections riscv_elf_size_dynamic_sections
4346 #define elf_backend_relocate_section riscv_elf_relocate_section
4347 #define elf_backend_finish_dynamic_symbol riscv_elf_finish_dynamic_symbol
4348 #define elf_backend_finish_dynamic_sections riscv_elf_finish_dynamic_sections
4349 #define elf_backend_gc_mark_hook riscv_elf_gc_mark_hook
4350 #define elf_backend_plt_sym_val riscv_elf_plt_sym_val
4351 #define elf_backend_grok_prstatus riscv_elf_grok_prstatus
4352 #define elf_backend_grok_psinfo riscv_elf_grok_psinfo
4353 #define elf_backend_object_p riscv_elf_object_p
4354 #define elf_info_to_howto_rel NULL
4355 #define elf_info_to_howto riscv_info_to_howto_rela
4356 #define bfd_elfNN_bfd_relax_section _bfd_riscv_relax_section
4357 #define bfd_elfNN_mkobject elfNN_riscv_mkobject
4359 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
4361 #define elf_backend_can_gc_sections 1
4362 #define elf_backend_can_refcount 1
4363 #define elf_backend_want_got_plt 1
4364 #define elf_backend_plt_readonly 1
4365 #define elf_backend_plt_alignment 4
4366 #define elf_backend_want_plt_sym 1
4367 #define elf_backend_got_header_size (ARCH_SIZE / 8)
4368 #define elf_backend_want_dynrelro 1
4369 #define elf_backend_rela_normal 1
4370 #define elf_backend_default_execstack 0
4372 #undef elf_backend_obj_attrs_vendor
4373 #define elf_backend_obj_attrs_vendor "riscv"
4374 #undef elf_backend_obj_attrs_arg_type
4375 #define elf_backend_obj_attrs_arg_type riscv_elf_obj_attrs_arg_type
4376 #undef elf_backend_obj_attrs_section_type
4377 #define elf_backend_obj_attrs_section_type SHT_RISCV_ATTRIBUTES
4378 #undef elf_backend_obj_attrs_section
4379 #define elf_backend_obj_attrs_section ".riscv.attributes"
4381 #include "elfNN-target.h"