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
);
1091 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
1092 read-only sections. */
1095 maybe_set_textrel (struct elf_link_hash_entry
*h
, void *info_p
)
1099 if (h
->root
.type
== bfd_link_hash_indirect
)
1102 sec
= _bfd_elf_readonly_dynrelocs (h
);
1105 struct bfd_link_info
*info
= (struct bfd_link_info
*) info_p
;
1107 info
->flags
|= DF_TEXTREL
;
1108 info
->callbacks
->minfo
1109 (_("%pB: dynamic relocation against `%pT' in read-only section `%pA'\n"),
1110 sec
->owner
, h
->root
.root
.string
, sec
);
1112 /* Not an error, just cut short the traversal. */
1119 riscv_elf_size_dynamic_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
1121 struct riscv_elf_link_hash_table
*htab
;
1126 htab
= riscv_elf_hash_table (info
);
1127 BFD_ASSERT (htab
!= NULL
);
1128 dynobj
= htab
->elf
.dynobj
;
1129 BFD_ASSERT (dynobj
!= NULL
);
1131 if (elf_hash_table (info
)->dynamic_sections_created
)
1133 /* Set the contents of the .interp section to the interpreter. */
1134 if (bfd_link_executable (info
) && !info
->nointerp
)
1136 s
= bfd_get_linker_section (dynobj
, ".interp");
1137 BFD_ASSERT (s
!= NULL
);
1138 s
->size
= strlen (ELFNN_DYNAMIC_INTERPRETER
) + 1;
1139 s
->contents
= (unsigned char *) ELFNN_DYNAMIC_INTERPRETER
;
1143 /* Set up .got offsets for local syms, and space for local dynamic
1145 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
1147 bfd_signed_vma
*local_got
;
1148 bfd_signed_vma
*end_local_got
;
1149 char *local_tls_type
;
1150 bfd_size_type locsymcount
;
1151 Elf_Internal_Shdr
*symtab_hdr
;
1154 if (! is_riscv_elf (ibfd
))
1157 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
1159 struct elf_dyn_relocs
*p
;
1161 for (p
= elf_section_data (s
)->local_dynrel
; p
!= NULL
; p
= p
->next
)
1163 if (!bfd_is_abs_section (p
->sec
)
1164 && bfd_is_abs_section (p
->sec
->output_section
))
1166 /* Input section has been discarded, either because
1167 it is a copy of a linkonce section or due to
1168 linker script /DISCARD/, so we'll be discarding
1171 else if (p
->count
!= 0)
1173 srel
= elf_section_data (p
->sec
)->sreloc
;
1174 srel
->size
+= p
->count
* sizeof (ElfNN_External_Rela
);
1175 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
1176 info
->flags
|= DF_TEXTREL
;
1181 local_got
= elf_local_got_refcounts (ibfd
);
1185 symtab_hdr
= &elf_symtab_hdr (ibfd
);
1186 locsymcount
= symtab_hdr
->sh_info
;
1187 end_local_got
= local_got
+ locsymcount
;
1188 local_tls_type
= _bfd_riscv_elf_local_got_tls_type (ibfd
);
1190 srel
= htab
->elf
.srelgot
;
1191 for (; local_got
< end_local_got
; ++local_got
, ++local_tls_type
)
1195 *local_got
= s
->size
;
1196 s
->size
+= RISCV_ELF_WORD_BYTES
;
1197 if (*local_tls_type
& GOT_TLS_GD
)
1198 s
->size
+= RISCV_ELF_WORD_BYTES
;
1199 if (bfd_link_pic (info
)
1200 || (*local_tls_type
& (GOT_TLS_GD
| GOT_TLS_IE
)))
1201 srel
->size
+= sizeof (ElfNN_External_Rela
);
1204 *local_got
= (bfd_vma
) -1;
1208 /* Allocate global sym .plt and .got entries, and space for global
1209 sym dynamic relocs. */
1210 elf_link_hash_traverse (&htab
->elf
, allocate_dynrelocs
, info
);
1212 if (htab
->elf
.sgotplt
)
1214 struct elf_link_hash_entry
*got
;
1215 got
= elf_link_hash_lookup (elf_hash_table (info
),
1216 "_GLOBAL_OFFSET_TABLE_",
1217 FALSE
, FALSE
, FALSE
);
1219 /* Don't allocate .got.plt section if there are no GOT nor PLT
1220 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
1222 || !got
->ref_regular_nonweak
)
1223 && (htab
->elf
.sgotplt
->size
== GOTPLT_HEADER_SIZE
)
1224 && (htab
->elf
.splt
== NULL
1225 || htab
->elf
.splt
->size
== 0)
1226 && (htab
->elf
.sgot
== NULL
1227 || (htab
->elf
.sgot
->size
1228 == get_elf_backend_data (output_bfd
)->got_header_size
)))
1229 htab
->elf
.sgotplt
->size
= 0;
1232 /* The check_relocs and adjust_dynamic_symbol entry points have
1233 determined the sizes of the various dynamic sections. Allocate
1235 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1237 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1240 if (s
== htab
->elf
.splt
1241 || s
== htab
->elf
.sgot
1242 || s
== htab
->elf
.sgotplt
1243 || s
== htab
->elf
.sdynbss
1244 || s
== htab
->elf
.sdynrelro
1245 || s
== htab
->sdyntdata
)
1247 /* Strip this section if we don't need it; see the
1250 else if (strncmp (s
->name
, ".rela", 5) == 0)
1254 /* We use the reloc_count field as a counter if we need
1255 to copy relocs into the output file. */
1261 /* It's not one of our sections. */
1267 /* If we don't need this section, strip it from the
1268 output file. This is mostly to handle .rela.bss and
1269 .rela.plt. We must create both sections in
1270 create_dynamic_sections, because they must be created
1271 before the linker maps input sections to output
1272 sections. The linker does that before
1273 adjust_dynamic_symbol is called, and it is that
1274 function which decides whether anything needs to go
1275 into these sections. */
1276 s
->flags
|= SEC_EXCLUDE
;
1280 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
1283 /* Allocate memory for the section contents. Zero the memory
1284 for the benefit of .rela.plt, which has 4 unused entries
1285 at the beginning, and we don't want garbage. */
1286 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
1287 if (s
->contents
== NULL
)
1291 if (elf_hash_table (info
)->dynamic_sections_created
)
1293 /* Add some entries to the .dynamic section. We fill in the
1294 values later, in riscv_elf_finish_dynamic_sections, but we
1295 must add the entries now so that we get the correct size for
1296 the .dynamic section. The DT_DEBUG entry is filled in by the
1297 dynamic linker and used by the debugger. */
1298 #define add_dynamic_entry(TAG, VAL) \
1299 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1301 if (bfd_link_executable (info
))
1303 if (!add_dynamic_entry (DT_DEBUG
, 0))
1307 if (htab
->elf
.srelplt
->size
!= 0)
1309 if (!add_dynamic_entry (DT_PLTGOT
, 0)
1310 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
1311 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
1312 || !add_dynamic_entry (DT_JMPREL
, 0))
1316 if (!add_dynamic_entry (DT_RELA
, 0)
1317 || !add_dynamic_entry (DT_RELASZ
, 0)
1318 || !add_dynamic_entry (DT_RELAENT
, sizeof (ElfNN_External_Rela
)))
1321 /* If any dynamic relocs apply to a read-only section,
1322 then we need a DT_TEXTREL entry. */
1323 if ((info
->flags
& DF_TEXTREL
) == 0)
1324 elf_link_hash_traverse (&htab
->elf
, maybe_set_textrel
, info
);
1326 if (info
->flags
& DF_TEXTREL
)
1328 if (!add_dynamic_entry (DT_TEXTREL
, 0))
1332 #undef add_dynamic_entry
1338 #define DTP_OFFSET 0x800
1340 /* Return the relocation value for a TLS dtp-relative reloc. */
1343 dtpoff (struct bfd_link_info
*info
, bfd_vma address
)
1345 /* If tls_sec is NULL, we should have signalled an error already. */
1346 if (elf_hash_table (info
)->tls_sec
== NULL
)
1348 return address
- elf_hash_table (info
)->tls_sec
->vma
- DTP_OFFSET
;
1351 /* Return the relocation value for a static TLS tp-relative relocation. */
1354 tpoff (struct bfd_link_info
*info
, bfd_vma address
)
1356 /* If tls_sec is NULL, we should have signalled an error already. */
1357 if (elf_hash_table (info
)->tls_sec
== NULL
)
1359 return address
- elf_hash_table (info
)->tls_sec
->vma
- TP_OFFSET
;
1362 /* Return the global pointer's value, or 0 if it is not in use. */
1365 riscv_global_pointer_value (struct bfd_link_info
*info
)
1367 struct bfd_link_hash_entry
*h
;
1369 h
= bfd_link_hash_lookup (info
->hash
, RISCV_GP_SYMBOL
, FALSE
, FALSE
, TRUE
);
1370 if (h
== NULL
|| h
->type
!= bfd_link_hash_defined
)
1373 return h
->u
.def
.value
+ sec_addr (h
->u
.def
.section
);
1376 /* Emplace a static relocation. */
1378 static bfd_reloc_status_type
1379 perform_relocation (const reloc_howto_type
*howto
,
1380 const Elf_Internal_Rela
*rel
,
1382 asection
*input_section
,
1386 if (howto
->pc_relative
)
1387 value
-= sec_addr (input_section
) + rel
->r_offset
;
1388 value
+= rel
->r_addend
;
1390 switch (ELFNN_R_TYPE (rel
->r_info
))
1393 case R_RISCV_TPREL_HI20
:
1394 case R_RISCV_PCREL_HI20
:
1395 case R_RISCV_GOT_HI20
:
1396 case R_RISCV_TLS_GOT_HI20
:
1397 case R_RISCV_TLS_GD_HI20
:
1398 if (ARCH_SIZE
> 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (value
)))
1399 return bfd_reloc_overflow
;
1400 value
= ENCODE_UTYPE_IMM (RISCV_CONST_HIGH_PART (value
));
1403 case R_RISCV_LO12_I
:
1404 case R_RISCV_GPREL_I
:
1405 case R_RISCV_TPREL_LO12_I
:
1406 case R_RISCV_TPREL_I
:
1407 case R_RISCV_PCREL_LO12_I
:
1408 value
= ENCODE_ITYPE_IMM (value
);
1411 case R_RISCV_LO12_S
:
1412 case R_RISCV_GPREL_S
:
1413 case R_RISCV_TPREL_LO12_S
:
1414 case R_RISCV_TPREL_S
:
1415 case R_RISCV_PCREL_LO12_S
:
1416 value
= ENCODE_STYPE_IMM (value
);
1420 case R_RISCV_CALL_PLT
:
1421 if (ARCH_SIZE
> 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (value
)))
1422 return bfd_reloc_overflow
;
1423 value
= ENCODE_UTYPE_IMM (RISCV_CONST_HIGH_PART (value
))
1424 | (ENCODE_ITYPE_IMM (value
) << 32);
1428 if (!VALID_UJTYPE_IMM (value
))
1429 return bfd_reloc_overflow
;
1430 value
= ENCODE_UJTYPE_IMM (value
);
1433 case R_RISCV_BRANCH
:
1434 if (!VALID_SBTYPE_IMM (value
))
1435 return bfd_reloc_overflow
;
1436 value
= ENCODE_SBTYPE_IMM (value
);
1439 case R_RISCV_RVC_BRANCH
:
1440 if (!VALID_RVC_B_IMM (value
))
1441 return bfd_reloc_overflow
;
1442 value
= ENCODE_RVC_B_IMM (value
);
1445 case R_RISCV_RVC_JUMP
:
1446 if (!VALID_RVC_J_IMM (value
))
1447 return bfd_reloc_overflow
;
1448 value
= ENCODE_RVC_J_IMM (value
);
1451 case R_RISCV_RVC_LUI
:
1452 if (RISCV_CONST_HIGH_PART (value
) == 0)
1454 /* Linker relaxation can convert an address equal to or greater than
1455 0x800 to slightly below 0x800. C.LUI does not accept zero as a
1456 valid immediate. We can fix this by converting it to a C.LI. */
1457 bfd_vma insn
= bfd_get (howto
->bitsize
, input_bfd
,
1458 contents
+ rel
->r_offset
);
1459 insn
= (insn
& ~MATCH_C_LUI
) | MATCH_C_LI
;
1460 bfd_put (howto
->bitsize
, input_bfd
, insn
, contents
+ rel
->r_offset
);
1461 value
= ENCODE_RVC_IMM (0);
1463 else if (!VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (value
)))
1464 return bfd_reloc_overflow
;
1466 value
= ENCODE_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (value
));
1484 case R_RISCV_32_PCREL
:
1485 case R_RISCV_TLS_DTPREL32
:
1486 case R_RISCV_TLS_DTPREL64
:
1489 case R_RISCV_DELETE
:
1490 return bfd_reloc_ok
;
1493 return bfd_reloc_notsupported
;
1496 bfd_vma word
= bfd_get (howto
->bitsize
, input_bfd
, contents
+ rel
->r_offset
);
1497 word
= (word
& ~howto
->dst_mask
) | (value
& howto
->dst_mask
);
1498 bfd_put (howto
->bitsize
, input_bfd
, word
, contents
+ rel
->r_offset
);
1500 return bfd_reloc_ok
;
1503 /* Remember all PC-relative high-part relocs we've encountered to help us
1504 later resolve the corresponding low-part relocs. */
1510 } riscv_pcrel_hi_reloc
;
1512 typedef struct riscv_pcrel_lo_reloc
1514 asection
* input_section
;
1515 struct bfd_link_info
* info
;
1516 reloc_howto_type
* howto
;
1517 const Elf_Internal_Rela
* reloc
;
1520 bfd_byte
* contents
;
1521 struct riscv_pcrel_lo_reloc
* next
;
1522 } riscv_pcrel_lo_reloc
;
1527 riscv_pcrel_lo_reloc
*lo_relocs
;
1528 } riscv_pcrel_relocs
;
1531 riscv_pcrel_reloc_hash (const void *entry
)
1533 const riscv_pcrel_hi_reloc
*e
= entry
;
1534 return (hashval_t
)(e
->address
>> 2);
1538 riscv_pcrel_reloc_eq (const void *entry1
, const void *entry2
)
1540 const riscv_pcrel_hi_reloc
*e1
= entry1
, *e2
= entry2
;
1541 return e1
->address
== e2
->address
;
1545 riscv_init_pcrel_relocs (riscv_pcrel_relocs
*p
)
1548 p
->lo_relocs
= NULL
;
1549 p
->hi_relocs
= htab_create (1024, riscv_pcrel_reloc_hash
,
1550 riscv_pcrel_reloc_eq
, free
);
1551 return p
->hi_relocs
!= NULL
;
1555 riscv_free_pcrel_relocs (riscv_pcrel_relocs
*p
)
1557 riscv_pcrel_lo_reloc
*cur
= p
->lo_relocs
;
1561 riscv_pcrel_lo_reloc
*next
= cur
->next
;
1566 htab_delete (p
->hi_relocs
);
1570 riscv_zero_pcrel_hi_reloc (Elf_Internal_Rela
*rel
,
1571 struct bfd_link_info
*info
,
1575 const reloc_howto_type
*howto
,
1578 /* We may need to reference low addreses in PC-relative modes even when the
1579 * PC is far away from these addresses. For example, undefweak references
1580 * need to produce the address 0 when linked. As 0 is far from the arbitrary
1581 * addresses that we can link PC-relative programs at, the linker can't
1582 * actually relocate references to those symbols. In order to allow these
1583 * programs to work we simply convert the PC-relative auipc sequences to
1584 * 0-relative lui sequences. */
1585 if (bfd_link_pic (info
))
1588 /* If it's possible to reference the symbol using auipc we do so, as that's
1589 * more in the spirit of the PC-relative relocations we're processing. */
1590 bfd_vma offset
= addr
- pc
;
1591 if (ARCH_SIZE
== 32 || VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (offset
)))
1594 /* If it's impossible to reference this with a LUI-based offset then don't
1595 * bother to convert it at all so users still see the PC-relative relocation
1596 * in the truncation message. */
1597 if (ARCH_SIZE
> 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (addr
)))
1600 rel
->r_info
= ELFNN_R_INFO(addr
, R_RISCV_HI20
);
1602 bfd_vma insn
= bfd_get(howto
->bitsize
, input_bfd
, contents
+ rel
->r_offset
);
1603 insn
= (insn
& ~MASK_AUIPC
) | MATCH_LUI
;
1604 bfd_put(howto
->bitsize
, input_bfd
, insn
, contents
+ rel
->r_offset
);
1609 riscv_record_pcrel_hi_reloc (riscv_pcrel_relocs
*p
, bfd_vma addr
,
1610 bfd_vma value
, bfd_boolean absolute
)
1612 bfd_vma offset
= absolute
? value
: value
- addr
;
1613 riscv_pcrel_hi_reloc entry
= {addr
, offset
};
1614 riscv_pcrel_hi_reloc
**slot
=
1615 (riscv_pcrel_hi_reloc
**) htab_find_slot (p
->hi_relocs
, &entry
, INSERT
);
1617 BFD_ASSERT (*slot
== NULL
);
1618 *slot
= (riscv_pcrel_hi_reloc
*) bfd_malloc (sizeof (riscv_pcrel_hi_reloc
));
1626 riscv_record_pcrel_lo_reloc (riscv_pcrel_relocs
*p
,
1627 asection
*input_section
,
1628 struct bfd_link_info
*info
,
1629 reloc_howto_type
*howto
,
1630 const Elf_Internal_Rela
*reloc
,
1635 riscv_pcrel_lo_reloc
*entry
;
1636 entry
= (riscv_pcrel_lo_reloc
*) bfd_malloc (sizeof (riscv_pcrel_lo_reloc
));
1639 *entry
= (riscv_pcrel_lo_reloc
) {input_section
, info
, howto
, reloc
, addr
,
1640 name
, contents
, p
->lo_relocs
};
1641 p
->lo_relocs
= entry
;
1646 riscv_resolve_pcrel_lo_relocs (riscv_pcrel_relocs
*p
)
1648 riscv_pcrel_lo_reloc
*r
;
1650 for (r
= p
->lo_relocs
; r
!= NULL
; r
= r
->next
)
1652 bfd
*input_bfd
= r
->input_section
->owner
;
1654 riscv_pcrel_hi_reloc search
= {r
->addr
, 0};
1655 riscv_pcrel_hi_reloc
*entry
= htab_find (p
->hi_relocs
, &search
);
1657 /* Check for overflow into bit 11 when adding reloc addend. */
1658 || (! (entry
->value
& 0x800)
1659 && ((entry
->value
+ r
->reloc
->r_addend
) & 0x800)))
1661 char *string
= (entry
== NULL
1662 ? "%pcrel_lo missing matching %pcrel_hi"
1663 : "%pcrel_lo overflow with an addend");
1664 (*r
->info
->callbacks
->reloc_dangerous
)
1665 (r
->info
, string
, input_bfd
, r
->input_section
, r
->reloc
->r_offset
);
1669 perform_relocation (r
->howto
, r
->reloc
, entry
->value
, r
->input_section
,
1670 input_bfd
, r
->contents
);
1676 /* Relocate a RISC-V ELF section.
1678 The RELOCATE_SECTION function is called by the new ELF backend linker
1679 to handle the relocations for a section.
1681 The relocs are always passed as Rela structures.
1683 This function is responsible for adjusting the section contents as
1684 necessary, and (if generating a relocatable output file) adjusting
1685 the reloc addend as necessary.
1687 This function does not have to worry about setting the reloc
1688 address or the reloc symbol index.
1690 LOCAL_SYMS is a pointer to the swapped in local symbols.
1692 LOCAL_SECTIONS is an array giving the section in the input file
1693 corresponding to the st_shndx field of each local symbol.
1695 The global hash table entry for the global symbols can be found
1696 via elf_sym_hashes (input_bfd).
1698 When generating relocatable output, this function must handle
1699 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
1700 going to be the section symbol corresponding to the output
1701 section, which means that the addend must be adjusted
1705 riscv_elf_relocate_section (bfd
*output_bfd
,
1706 struct bfd_link_info
*info
,
1708 asection
*input_section
,
1710 Elf_Internal_Rela
*relocs
,
1711 Elf_Internal_Sym
*local_syms
,
1712 asection
**local_sections
)
1714 Elf_Internal_Rela
*rel
;
1715 Elf_Internal_Rela
*relend
;
1716 riscv_pcrel_relocs pcrel_relocs
;
1717 bfd_boolean ret
= FALSE
;
1718 asection
*sreloc
= elf_section_data (input_section
)->sreloc
;
1719 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
1720 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (input_bfd
);
1721 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (input_bfd
);
1722 bfd_vma
*local_got_offsets
= elf_local_got_offsets (input_bfd
);
1723 bfd_boolean absolute
;
1725 if (!riscv_init_pcrel_relocs (&pcrel_relocs
))
1728 relend
= relocs
+ input_section
->reloc_count
;
1729 for (rel
= relocs
; rel
< relend
; rel
++)
1731 unsigned long r_symndx
;
1732 struct elf_link_hash_entry
*h
;
1733 Elf_Internal_Sym
*sym
;
1736 bfd_reloc_status_type r
= bfd_reloc_ok
;
1738 bfd_vma off
, ie_off
;
1739 bfd_boolean unresolved_reloc
, is_ie
= FALSE
;
1740 bfd_vma pc
= sec_addr (input_section
) + rel
->r_offset
;
1741 int r_type
= ELFNN_R_TYPE (rel
->r_info
), tls_type
;
1742 reloc_howto_type
*howto
= riscv_elf_rtype_to_howto (input_bfd
, r_type
);
1743 const char *msg
= NULL
;
1744 char *msg_buf
= NULL
;
1745 bfd_boolean resolved_to_zero
;
1748 || r_type
== R_RISCV_GNU_VTINHERIT
|| r_type
== R_RISCV_GNU_VTENTRY
)
1751 /* This is a final link. */
1752 r_symndx
= ELFNN_R_SYM (rel
->r_info
);
1756 unresolved_reloc
= FALSE
;
1757 if (r_symndx
< symtab_hdr
->sh_info
)
1759 sym
= local_syms
+ r_symndx
;
1760 sec
= local_sections
[r_symndx
];
1761 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
1765 bfd_boolean warned
, ignored
;
1767 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
1768 r_symndx
, symtab_hdr
, sym_hashes
,
1770 unresolved_reloc
, warned
, ignored
);
1773 /* To avoid generating warning messages about truncated
1774 relocations, set the relocation's address to be the same as
1775 the start of this section. */
1776 if (input_section
->output_section
!= NULL
)
1777 relocation
= input_section
->output_section
->vma
;
1783 if (sec
!= NULL
&& discarded_section (sec
))
1784 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
1785 rel
, 1, relend
, howto
, 0, contents
);
1787 if (bfd_link_relocatable (info
))
1791 name
= h
->root
.root
.string
;
1794 name
= (bfd_elf_string_from_elf_section
1795 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
1796 if (name
== NULL
|| *name
== '\0')
1797 name
= bfd_section_name (sec
);
1800 resolved_to_zero
= (h
!= NULL
1801 && UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
));
1807 case R_RISCV_TPREL_ADD
:
1809 case R_RISCV_JUMP_SLOT
:
1810 case R_RISCV_RELATIVE
:
1811 /* These require nothing of us at all. */
1815 case R_RISCV_BRANCH
:
1816 case R_RISCV_RVC_BRANCH
:
1817 case R_RISCV_RVC_LUI
:
1818 case R_RISCV_LO12_I
:
1819 case R_RISCV_LO12_S
:
1824 case R_RISCV_32_PCREL
:
1825 case R_RISCV_DELETE
:
1826 /* These require no special handling beyond perform_relocation. */
1829 case R_RISCV_GOT_HI20
:
1832 bfd_boolean dyn
, pic
;
1834 off
= h
->got
.offset
;
1835 BFD_ASSERT (off
!= (bfd_vma
) -1);
1836 dyn
= elf_hash_table (info
)->dynamic_sections_created
;
1837 pic
= bfd_link_pic (info
);
1839 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, pic
, h
)
1840 || (pic
&& SYMBOL_REFERENCES_LOCAL (info
, h
)))
1842 /* This is actually a static link, or it is a
1843 -Bsymbolic link and the symbol is defined
1844 locally, or the symbol was forced to be local
1845 because of a version file. We must initialize
1846 this entry in the global offset table. Since the
1847 offset must always be a multiple of the word size,
1848 we use the least significant bit to record whether
1849 we have initialized it already.
1851 When doing a dynamic link, we create a .rela.got
1852 relocation entry to initialize the value. This
1853 is done in the finish_dynamic_symbol routine. */
1858 bfd_put_NN (output_bfd
, relocation
,
1859 htab
->elf
.sgot
->contents
+ off
);
1864 unresolved_reloc
= FALSE
;
1868 BFD_ASSERT (local_got_offsets
!= NULL
1869 && local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
1871 off
= local_got_offsets
[r_symndx
];
1873 /* The offset must always be a multiple of the word size.
1874 So, we can use the least significant bit to record
1875 whether we have already processed this entry. */
1880 if (bfd_link_pic (info
))
1883 Elf_Internal_Rela outrel
;
1885 /* We need to generate a R_RISCV_RELATIVE reloc
1886 for the dynamic linker. */
1887 s
= htab
->elf
.srelgot
;
1888 BFD_ASSERT (s
!= NULL
);
1890 outrel
.r_offset
= sec_addr (htab
->elf
.sgot
) + off
;
1892 ELFNN_R_INFO (0, R_RISCV_RELATIVE
);
1893 outrel
.r_addend
= relocation
;
1895 riscv_elf_append_rela (output_bfd
, s
, &outrel
);
1898 bfd_put_NN (output_bfd
, relocation
,
1899 htab
->elf
.sgot
->contents
+ off
);
1900 local_got_offsets
[r_symndx
] |= 1;
1903 relocation
= sec_addr (htab
->elf
.sgot
) + off
;
1904 absolute
= riscv_zero_pcrel_hi_reloc (rel
,
1911 r_type
= ELFNN_R_TYPE (rel
->r_info
);
1912 howto
= riscv_elf_rtype_to_howto (input_bfd
, r_type
);
1914 r
= bfd_reloc_notsupported
;
1915 else if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs
, pc
,
1916 relocation
, absolute
))
1917 r
= bfd_reloc_overflow
;
1925 bfd_vma old_value
= bfd_get (howto
->bitsize
, input_bfd
,
1926 contents
+ rel
->r_offset
);
1927 relocation
= old_value
+ relocation
;
1937 bfd_vma old_value
= bfd_get (howto
->bitsize
, input_bfd
,
1938 contents
+ rel
->r_offset
);
1939 relocation
= old_value
- relocation
;
1944 case R_RISCV_CALL_PLT
:
1945 /* Handle a call to an undefined weak function. This won't be
1946 relaxed, so we have to handle it here. */
1947 if (h
!= NULL
&& h
->root
.type
== bfd_link_hash_undefweak
1948 && (!bfd_link_pic (info
) || h
->plt
.offset
== MINUS_ONE
))
1950 /* We can use x0 as the base register. */
1951 bfd_vma insn
= bfd_get_32 (input_bfd
,
1952 contents
+ rel
->r_offset
+ 4);
1953 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
1954 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
+ 4);
1955 /* Set the relocation value so that we get 0 after the pc
1956 relative adjustment. */
1957 relocation
= sec_addr (input_section
) + rel
->r_offset
;
1962 case R_RISCV_RVC_JUMP
:
1963 /* This line has to match the check in _bfd_riscv_relax_section. */
1964 if (bfd_link_pic (info
) && h
!= NULL
&& h
->plt
.offset
!= MINUS_ONE
)
1966 /* Refer to the PLT entry. */
1967 relocation
= sec_addr (htab
->elf
.splt
) + h
->plt
.offset
;
1968 unresolved_reloc
= FALSE
;
1972 case R_RISCV_TPREL_HI20
:
1973 relocation
= tpoff (info
, relocation
);
1976 case R_RISCV_TPREL_LO12_I
:
1977 case R_RISCV_TPREL_LO12_S
:
1978 relocation
= tpoff (info
, relocation
);
1981 case R_RISCV_TPREL_I
:
1982 case R_RISCV_TPREL_S
:
1983 relocation
= tpoff (info
, relocation
);
1984 if (VALID_ITYPE_IMM (relocation
+ rel
->r_addend
))
1986 /* We can use tp as the base register. */
1987 bfd_vma insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
1988 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
1989 insn
|= X_TP
<< OP_SH_RS1
;
1990 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
1993 r
= bfd_reloc_overflow
;
1996 case R_RISCV_GPREL_I
:
1997 case R_RISCV_GPREL_S
:
1999 bfd_vma gp
= riscv_global_pointer_value (info
);
2000 bfd_boolean x0_base
= VALID_ITYPE_IMM (relocation
+ rel
->r_addend
);
2001 if (x0_base
|| VALID_ITYPE_IMM (relocation
+ rel
->r_addend
- gp
))
2003 /* We can use x0 or gp as the base register. */
2004 bfd_vma insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2005 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
2008 rel
->r_addend
-= gp
;
2009 insn
|= X_GP
<< OP_SH_RS1
;
2011 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
2014 r
= bfd_reloc_overflow
;
2018 case R_RISCV_PCREL_HI20
:
2019 absolute
= riscv_zero_pcrel_hi_reloc (rel
,
2026 r_type
= ELFNN_R_TYPE (rel
->r_info
);
2027 howto
= riscv_elf_rtype_to_howto (input_bfd
, r_type
);
2029 r
= bfd_reloc_notsupported
;
2030 else if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs
, pc
,
2031 relocation
+ rel
->r_addend
,
2033 r
= bfd_reloc_overflow
;
2036 case R_RISCV_PCREL_LO12_I
:
2037 case R_RISCV_PCREL_LO12_S
:
2038 /* We don't allow section symbols plus addends as the auipc address,
2039 because then riscv_relax_delete_bytes would have to search through
2040 all relocs to update these addends. This is also ambiguous, as
2041 we do allow offsets to be added to the target address, which are
2042 not to be used to find the auipc address. */
2043 if (((sym
!= NULL
&& (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
))
2044 || (h
!= NULL
&& h
->type
== STT_SECTION
))
2047 msg
= _("%pcrel_lo section symbol with an addend");
2048 r
= bfd_reloc_dangerous
;
2052 if (riscv_record_pcrel_lo_reloc (&pcrel_relocs
, input_section
, info
,
2053 howto
, rel
, relocation
, name
,
2056 r
= bfd_reloc_overflow
;
2059 case R_RISCV_TLS_DTPREL32
:
2060 case R_RISCV_TLS_DTPREL64
:
2061 relocation
= dtpoff (info
, relocation
);
2066 if ((input_section
->flags
& SEC_ALLOC
) == 0)
2069 if ((bfd_link_pic (info
)
2071 || (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2072 && !resolved_to_zero
)
2073 || h
->root
.type
!= bfd_link_hash_undefweak
)
2074 && (! howto
->pc_relative
2075 || !SYMBOL_CALLS_LOCAL (info
, h
)))
2076 || (!bfd_link_pic (info
)
2082 || h
->root
.type
== bfd_link_hash_undefweak
2083 || h
->root
.type
== bfd_link_hash_undefined
)))
2085 Elf_Internal_Rela outrel
;
2086 bfd_boolean skip_static_relocation
, skip_dynamic_relocation
;
2088 /* When generating a shared object, these relocations
2089 are copied into the output file to be resolved at run
2093 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
2095 skip_static_relocation
= outrel
.r_offset
!= (bfd_vma
) -2;
2096 skip_dynamic_relocation
= outrel
.r_offset
>= (bfd_vma
) -2;
2097 outrel
.r_offset
+= sec_addr (input_section
);
2099 if (skip_dynamic_relocation
)
2100 memset (&outrel
, 0, sizeof outrel
);
2101 else if (h
!= NULL
&& h
->dynindx
!= -1
2102 && !(bfd_link_pic (info
)
2103 && SYMBOLIC_BIND (info
, h
)
2106 outrel
.r_info
= ELFNN_R_INFO (h
->dynindx
, r_type
);
2107 outrel
.r_addend
= rel
->r_addend
;
2111 outrel
.r_info
= ELFNN_R_INFO (0, R_RISCV_RELATIVE
);
2112 outrel
.r_addend
= relocation
+ rel
->r_addend
;
2115 riscv_elf_append_rela (output_bfd
, sreloc
, &outrel
);
2116 if (skip_static_relocation
)
2121 case R_RISCV_TLS_GOT_HI20
:
2125 case R_RISCV_TLS_GD_HI20
:
2128 off
= h
->got
.offset
;
2133 off
= local_got_offsets
[r_symndx
];
2134 local_got_offsets
[r_symndx
] |= 1;
2137 tls_type
= _bfd_riscv_elf_tls_type (input_bfd
, h
, r_symndx
);
2138 BFD_ASSERT (tls_type
& (GOT_TLS_IE
| GOT_TLS_GD
));
2139 /* If this symbol is referenced by both GD and IE TLS, the IE
2140 reference's GOT slot follows the GD reference's slots. */
2142 if ((tls_type
& GOT_TLS_GD
) && (tls_type
& GOT_TLS_IE
))
2143 ie_off
= 2 * GOT_ENTRY_SIZE
;
2149 Elf_Internal_Rela outrel
;
2151 bfd_boolean need_relocs
= FALSE
;
2153 if (htab
->elf
.srelgot
== NULL
)
2158 bfd_boolean dyn
, pic
;
2159 dyn
= htab
->elf
.dynamic_sections_created
;
2160 pic
= bfd_link_pic (info
);
2162 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, pic
, h
)
2163 && (!pic
|| !SYMBOL_REFERENCES_LOCAL (info
, h
)))
2167 /* The GOT entries have not been initialized yet. Do it
2168 now, and emit any relocations. */
2169 if ((bfd_link_pic (info
) || indx
!= 0)
2171 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2172 || h
->root
.type
!= bfd_link_hash_undefweak
))
2175 if (tls_type
& GOT_TLS_GD
)
2179 outrel
.r_offset
= sec_addr (htab
->elf
.sgot
) + off
;
2180 outrel
.r_addend
= 0;
2181 outrel
.r_info
= ELFNN_R_INFO (indx
, R_RISCV_TLS_DTPMODNN
);
2182 bfd_put_NN (output_bfd
, 0,
2183 htab
->elf
.sgot
->contents
+ off
);
2184 riscv_elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &outrel
);
2187 BFD_ASSERT (! unresolved_reloc
);
2188 bfd_put_NN (output_bfd
,
2189 dtpoff (info
, relocation
),
2190 (htab
->elf
.sgot
->contents
+ off
+
2191 RISCV_ELF_WORD_BYTES
));
2195 bfd_put_NN (output_bfd
, 0,
2196 (htab
->elf
.sgot
->contents
+ off
+
2197 RISCV_ELF_WORD_BYTES
));
2198 outrel
.r_info
= ELFNN_R_INFO (indx
, R_RISCV_TLS_DTPRELNN
);
2199 outrel
.r_offset
+= RISCV_ELF_WORD_BYTES
;
2200 riscv_elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &outrel
);
2205 /* If we are not emitting relocations for a
2206 general dynamic reference, then we must be in a
2207 static link or an executable link with the
2208 symbol binding locally. Mark it as belonging
2209 to module 1, the executable. */
2210 bfd_put_NN (output_bfd
, 1,
2211 htab
->elf
.sgot
->contents
+ off
);
2212 bfd_put_NN (output_bfd
,
2213 dtpoff (info
, relocation
),
2214 (htab
->elf
.sgot
->contents
+ off
+
2215 RISCV_ELF_WORD_BYTES
));
2219 if (tls_type
& GOT_TLS_IE
)
2223 bfd_put_NN (output_bfd
, 0,
2224 htab
->elf
.sgot
->contents
+ off
+ ie_off
);
2225 outrel
.r_offset
= sec_addr (htab
->elf
.sgot
)
2227 outrel
.r_addend
= 0;
2229 outrel
.r_addend
= tpoff (info
, relocation
);
2230 outrel
.r_info
= ELFNN_R_INFO (indx
, R_RISCV_TLS_TPRELNN
);
2231 riscv_elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &outrel
);
2235 bfd_put_NN (output_bfd
, tpoff (info
, relocation
),
2236 htab
->elf
.sgot
->contents
+ off
+ ie_off
);
2241 BFD_ASSERT (off
< (bfd_vma
) -2);
2242 relocation
= sec_addr (htab
->elf
.sgot
) + off
+ (is_ie
? ie_off
: 0);
2243 if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs
, pc
,
2245 r
= bfd_reloc_overflow
;
2246 unresolved_reloc
= FALSE
;
2250 r
= bfd_reloc_notsupported
;
2253 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2254 because such sections are not SEC_ALLOC and thus ld.so will
2255 not process them. */
2256 if (unresolved_reloc
2257 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
2259 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
2260 rel
->r_offset
) != (bfd_vma
) -1)
2266 case R_RISCV_RVC_JUMP
:
2267 if (asprintf (&msg_buf
,
2268 _("%%X%%P: relocation %s against `%s' can "
2269 "not be used when making a shared object; "
2270 "recompile with -fPIC\n"),
2272 h
->root
.root
.string
) == -1)
2277 if (asprintf (&msg_buf
,
2278 _("%%X%%P: unresolvable %s relocation against "
2281 h
->root
.root
.string
) == -1)
2287 r
= bfd_reloc_notsupported
;
2290 if (r
== bfd_reloc_ok
)
2291 r
= perform_relocation (howto
, rel
, relocation
, input_section
,
2292 input_bfd
, contents
);
2294 /* We should have already detected the error and set message before.
2295 If the error message isn't set since the linker runs out of memory
2296 or we don't set it before, then we should set the default message
2297 with the "internal error" string here. */
2303 case bfd_reloc_overflow
:
2304 info
->callbacks
->reloc_overflow
2305 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
2306 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
2309 case bfd_reloc_undefined
:
2310 info
->callbacks
->undefined_symbol
2311 (info
, name
, input_bfd
, input_section
, rel
->r_offset
,
2315 case bfd_reloc_outofrange
:
2317 msg
= _("%X%P: internal error: out of range error\n");
2320 case bfd_reloc_notsupported
:
2322 msg
= _("%X%P: internal error: unsupported relocation error\n");
2325 case bfd_reloc_dangerous
:
2326 /* The error message should already be set. */
2328 msg
= _("dangerous relocation error");
2329 info
->callbacks
->reloc_dangerous
2330 (info
, msg
, input_bfd
, input_section
, rel
->r_offset
);
2334 msg
= _("%X%P: internal error: unknown error\n");
2338 /* Do not report error message for the dangerous relocation again. */
2339 if (msg
&& r
!= bfd_reloc_dangerous
)
2340 info
->callbacks
->einfo (msg
);
2342 /* Free the unused `msg_buf`. */
2345 /* We already reported the error via a callback, so don't try to report
2346 it again by returning false. That leads to spurious errors. */
2351 ret
= riscv_resolve_pcrel_lo_relocs (&pcrel_relocs
);
2353 riscv_free_pcrel_relocs (&pcrel_relocs
);
2357 /* Finish up dynamic symbol handling. We set the contents of various
2358 dynamic sections here. */
2361 riscv_elf_finish_dynamic_symbol (bfd
*output_bfd
,
2362 struct bfd_link_info
*info
,
2363 struct elf_link_hash_entry
*h
,
2364 Elf_Internal_Sym
*sym
)
2366 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
2367 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
2369 if (h
->plt
.offset
!= (bfd_vma
) -1)
2371 /* We've decided to create a PLT entry for this symbol. */
2373 bfd_vma i
, header_address
, plt_idx
, got_address
;
2374 uint32_t plt_entry
[PLT_ENTRY_INSNS
];
2375 Elf_Internal_Rela rela
;
2377 BFD_ASSERT (h
->dynindx
!= -1);
2379 /* Calculate the address of the PLT header. */
2380 header_address
= sec_addr (htab
->elf
.splt
);
2382 /* Calculate the index of the entry. */
2383 plt_idx
= (h
->plt
.offset
- PLT_HEADER_SIZE
) / PLT_ENTRY_SIZE
;
2385 /* Calculate the address of the .got.plt entry. */
2386 got_address
= riscv_elf_got_plt_val (plt_idx
, info
);
2388 /* Find out where the .plt entry should go. */
2389 loc
= htab
->elf
.splt
->contents
+ h
->plt
.offset
;
2391 /* Fill in the PLT entry itself. */
2392 if (! riscv_make_plt_entry (output_bfd
, got_address
,
2393 header_address
+ h
->plt
.offset
,
2397 for (i
= 0; i
< PLT_ENTRY_INSNS
; i
++)
2398 bfd_put_32 (output_bfd
, plt_entry
[i
], loc
+ 4*i
);
2400 /* Fill in the initial value of the .got.plt entry. */
2401 loc
= htab
->elf
.sgotplt
->contents
2402 + (got_address
- sec_addr (htab
->elf
.sgotplt
));
2403 bfd_put_NN (output_bfd
, sec_addr (htab
->elf
.splt
), loc
);
2405 /* Fill in the entry in the .rela.plt section. */
2406 rela
.r_offset
= got_address
;
2408 rela
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_RISCV_JUMP_SLOT
);
2410 loc
= htab
->elf
.srelplt
->contents
+ plt_idx
* sizeof (ElfNN_External_Rela
);
2411 bed
->s
->swap_reloca_out (output_bfd
, &rela
, loc
);
2413 if (!h
->def_regular
)
2415 /* Mark the symbol as undefined, rather than as defined in
2416 the .plt section. Leave the value alone. */
2417 sym
->st_shndx
= SHN_UNDEF
;
2418 /* If the symbol is weak, we do need to clear the value.
2419 Otherwise, the PLT entry would provide a definition for
2420 the symbol even if the symbol wasn't defined anywhere,
2421 and so the symbol would never be NULL. */
2422 if (!h
->ref_regular_nonweak
)
2427 if (h
->got
.offset
!= (bfd_vma
) -1
2428 && !(riscv_elf_hash_entry (h
)->tls_type
& (GOT_TLS_GD
| GOT_TLS_IE
))
2429 && !UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
2433 Elf_Internal_Rela rela
;
2435 /* This symbol has an entry in the GOT. Set it up. */
2437 sgot
= htab
->elf
.sgot
;
2438 srela
= htab
->elf
.srelgot
;
2439 BFD_ASSERT (sgot
!= NULL
&& srela
!= NULL
);
2441 rela
.r_offset
= sec_addr (sgot
) + (h
->got
.offset
&~ (bfd_vma
) 1);
2443 /* If this is a local symbol reference, we just want to emit a RELATIVE
2444 reloc. This can happen if it is a -Bsymbolic link, or a pie link, or
2445 the symbol was forced to be local because of a version file.
2446 The entry in the global offset table will already have been
2447 initialized in the relocate_section function. */
2448 if (bfd_link_pic (info
)
2449 && SYMBOL_REFERENCES_LOCAL (info
, h
))
2451 BFD_ASSERT((h
->got
.offset
& 1) != 0);
2452 asection
*sec
= h
->root
.u
.def
.section
;
2453 rela
.r_info
= ELFNN_R_INFO (0, R_RISCV_RELATIVE
);
2454 rela
.r_addend
= (h
->root
.u
.def
.value
2455 + sec
->output_section
->vma
2456 + sec
->output_offset
);
2460 BFD_ASSERT((h
->got
.offset
& 1) == 0);
2461 BFD_ASSERT (h
->dynindx
!= -1);
2462 rela
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_RISCV_NN
);
2466 bfd_put_NN (output_bfd
, 0,
2467 sgot
->contents
+ (h
->got
.offset
& ~(bfd_vma
) 1));
2468 riscv_elf_append_rela (output_bfd
, srela
, &rela
);
2473 Elf_Internal_Rela rela
;
2476 /* This symbols needs a copy reloc. Set it up. */
2477 BFD_ASSERT (h
->dynindx
!= -1);
2479 rela
.r_offset
= sec_addr (h
->root
.u
.def
.section
) + h
->root
.u
.def
.value
;
2480 rela
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_RISCV_COPY
);
2482 if (h
->root
.u
.def
.section
== htab
->elf
.sdynrelro
)
2483 s
= htab
->elf
.sreldynrelro
;
2485 s
= htab
->elf
.srelbss
;
2486 riscv_elf_append_rela (output_bfd
, s
, &rela
);
2489 /* Mark some specially defined symbols as absolute. */
2490 if (h
== htab
->elf
.hdynamic
2491 || (h
== htab
->elf
.hgot
|| h
== htab
->elf
.hplt
))
2492 sym
->st_shndx
= SHN_ABS
;
2497 /* Finish up the dynamic sections. */
2500 riscv_finish_dyn (bfd
*output_bfd
, struct bfd_link_info
*info
,
2501 bfd
*dynobj
, asection
*sdyn
)
2503 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
2504 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
2505 size_t dynsize
= bed
->s
->sizeof_dyn
;
2506 bfd_byte
*dyncon
, *dynconend
;
2508 dynconend
= sdyn
->contents
+ sdyn
->size
;
2509 for (dyncon
= sdyn
->contents
; dyncon
< dynconend
; dyncon
+= dynsize
)
2511 Elf_Internal_Dyn dyn
;
2514 bed
->s
->swap_dyn_in (dynobj
, dyncon
, &dyn
);
2519 s
= htab
->elf
.sgotplt
;
2520 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
2523 s
= htab
->elf
.srelplt
;
2524 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
2527 s
= htab
->elf
.srelplt
;
2528 dyn
.d_un
.d_val
= s
->size
;
2534 bed
->s
->swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2540 riscv_elf_finish_dynamic_sections (bfd
*output_bfd
,
2541 struct bfd_link_info
*info
)
2545 struct riscv_elf_link_hash_table
*htab
;
2547 htab
= riscv_elf_hash_table (info
);
2548 BFD_ASSERT (htab
!= NULL
);
2549 dynobj
= htab
->elf
.dynobj
;
2551 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
2553 if (elf_hash_table (info
)->dynamic_sections_created
)
2558 splt
= htab
->elf
.splt
;
2559 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
2561 ret
= riscv_finish_dyn (output_bfd
, info
, dynobj
, sdyn
);
2566 /* Fill in the head and tail entries in the procedure linkage table. */
2570 uint32_t plt_header
[PLT_HEADER_INSNS
];
2571 ret
= riscv_make_plt_header (output_bfd
,
2572 sec_addr (htab
->elf
.sgotplt
),
2573 sec_addr (splt
), plt_header
);
2577 for (i
= 0; i
< PLT_HEADER_INSNS
; i
++)
2578 bfd_put_32 (output_bfd
, plt_header
[i
], splt
->contents
+ 4*i
);
2580 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
2585 if (htab
->elf
.sgotplt
)
2587 asection
*output_section
= htab
->elf
.sgotplt
->output_section
;
2589 if (bfd_is_abs_section (output_section
))
2591 (*_bfd_error_handler
)
2592 (_("discarded output section: `%pA'"), htab
->elf
.sgotplt
);
2596 if (htab
->elf
.sgotplt
->size
> 0)
2598 /* Write the first two entries in .got.plt, needed for the dynamic
2600 bfd_put_NN (output_bfd
, (bfd_vma
) -1, htab
->elf
.sgotplt
->contents
);
2601 bfd_put_NN (output_bfd
, (bfd_vma
) 0,
2602 htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
);
2605 elf_section_data (output_section
)->this_hdr
.sh_entsize
= GOT_ENTRY_SIZE
;
2610 asection
*output_section
= htab
->elf
.sgot
->output_section
;
2612 if (htab
->elf
.sgot
->size
> 0)
2614 /* Set the first entry in the global offset table to the address of
2615 the dynamic section. */
2616 bfd_vma val
= sdyn
? sec_addr (sdyn
) : 0;
2617 bfd_put_NN (output_bfd
, val
, htab
->elf
.sgot
->contents
);
2620 elf_section_data (output_section
)->this_hdr
.sh_entsize
= GOT_ENTRY_SIZE
;
2626 /* Return address for Ith PLT stub in section PLT, for relocation REL
2627 or (bfd_vma) -1 if it should not be included. */
2630 riscv_elf_plt_sym_val (bfd_vma i
, const asection
*plt
,
2631 const arelent
*rel ATTRIBUTE_UNUSED
)
2633 return plt
->vma
+ PLT_HEADER_SIZE
+ i
* PLT_ENTRY_SIZE
;
2636 static enum elf_reloc_type_class
2637 riscv_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2638 const asection
*rel_sec ATTRIBUTE_UNUSED
,
2639 const Elf_Internal_Rela
*rela
)
2641 switch (ELFNN_R_TYPE (rela
->r_info
))
2643 case R_RISCV_RELATIVE
:
2644 return reloc_class_relative
;
2645 case R_RISCV_JUMP_SLOT
:
2646 return reloc_class_plt
;
2648 return reloc_class_copy
;
2650 return reloc_class_normal
;
2654 /* Given the ELF header flags in FLAGS, it returns a string that describes the
2658 riscv_float_abi_string (flagword flags
)
2660 switch (flags
& EF_RISCV_FLOAT_ABI
)
2662 case EF_RISCV_FLOAT_ABI_SOFT
:
2663 return "soft-float";
2665 case EF_RISCV_FLOAT_ABI_SINGLE
:
2666 return "single-float";
2668 case EF_RISCV_FLOAT_ABI_DOUBLE
:
2669 return "double-float";
2671 case EF_RISCV_FLOAT_ABI_QUAD
:
2672 return "quad-float";
2679 /* The information of architecture attribute. */
2680 static riscv_subset_list_t in_subsets
;
2681 static riscv_subset_list_t out_subsets
;
2682 static riscv_subset_list_t merged_subsets
;
2684 /* Predicator for standard extension. */
2687 riscv_std_ext_p (const char *name
)
2689 return (strlen (name
) == 1) && (name
[0] != 'x') && (name
[0] != 's');
2692 /* Error handler when version mis-match. */
2695 riscv_version_mismatch (bfd
*ibfd
,
2696 struct riscv_subset_t
*in
,
2697 struct riscv_subset_t
*out
)
2700 (_("error: %pB: Mis-matched ISA version for '%s' extension. "
2703 in
->major_version
, in
->minor_version
,
2704 out
->major_version
, out
->minor_version
);
2707 /* Return true if subset is 'i' or 'e'. */
2710 riscv_i_or_e_p (bfd
*ibfd
,
2712 struct riscv_subset_t
*subset
)
2714 if ((strcasecmp (subset
->name
, "e") != 0)
2715 && (strcasecmp (subset
->name
, "i") != 0))
2718 (_("error: %pB: corrupted ISA string '%s'. "
2719 "First letter should be 'i' or 'e' but got '%s'."),
2720 ibfd
, arch
, subset
->name
);
2726 /* Merge standard extensions.
2729 Return FALSE if failed to merge.
2733 `in_arch`: Raw arch string for input object.
2734 `out_arch`: Raw arch string for output object.
2735 `pin`: subset list for input object, and it'll skip all merged subset after
2737 `pout`: Like `pin`, but for output object. */
2740 riscv_merge_std_ext (bfd
*ibfd
,
2741 const char *in_arch
,
2742 const char *out_arch
,
2743 struct riscv_subset_t
**pin
,
2744 struct riscv_subset_t
**pout
)
2746 const char *standard_exts
= riscv_supported_std_ext ();
2748 struct riscv_subset_t
*in
= *pin
;
2749 struct riscv_subset_t
*out
= *pout
;
2751 /* First letter should be 'i' or 'e'. */
2752 if (!riscv_i_or_e_p (ibfd
, in_arch
, in
))
2755 if (!riscv_i_or_e_p (ibfd
, out_arch
, out
))
2758 if (strcasecmp (in
->name
, out
->name
) != 0)
2760 /* TODO: We might allow merge 'i' with 'e'. */
2762 (_("error: %pB: Mis-matched ISA string to merge '%s' and '%s'."),
2763 ibfd
, in
->name
, out
->name
);
2766 else if ((in
->major_version
!= out
->major_version
) ||
2767 (in
->minor_version
!= out
->minor_version
))
2769 /* TODO: Allow different merge policy. */
2770 riscv_version_mismatch (ibfd
, in
, out
);
2774 riscv_add_subset (&merged_subsets
,
2775 in
->name
, in
->major_version
, in
->minor_version
);
2780 /* Handle standard extension first. */
2781 for (p
= standard_exts
; *p
; ++p
)
2783 char find_ext
[2] = {*p
, '\0'};
2784 struct riscv_subset_t
*find_in
=
2785 riscv_lookup_subset (&in_subsets
, find_ext
);
2786 struct riscv_subset_t
*find_out
=
2787 riscv_lookup_subset (&out_subsets
, find_ext
);
2789 if (find_in
== NULL
&& find_out
== NULL
)
2792 /* Check version is same or not. */
2793 /* TODO: Allow different merge policy. */
2794 if ((find_in
!= NULL
&& find_out
!= NULL
)
2795 && ((find_in
->major_version
!= find_out
->major_version
)
2796 || (find_in
->minor_version
!= find_out
->minor_version
)))
2798 riscv_version_mismatch (ibfd
, in
, out
);
2802 struct riscv_subset_t
*merged
= find_in
? find_in
: find_out
;
2803 riscv_add_subset (&merged_subsets
, merged
->name
,
2804 merged
->major_version
, merged
->minor_version
);
2807 /* Skip all standard extensions. */
2808 while ((in
!= NULL
) && riscv_std_ext_p (in
->name
)) in
= in
->next
;
2809 while ((out
!= NULL
) && riscv_std_ext_p (out
->name
)) out
= out
->next
;
2817 /* If C is a prefix class, then return the EXT string without the prefix.
2818 Otherwise return the entire EXT string. */
2821 riscv_skip_prefix (const char *ext
, riscv_isa_ext_class_t c
)
2825 case RV_ISA_CLASS_X
: return &ext
[1];
2826 case RV_ISA_CLASS_S
: return &ext
[1];
2827 case RV_ISA_CLASS_Z
: return &ext
[1];
2828 default: return ext
;
2832 /* Compare prefixed extension names canonically. */
2835 riscv_prefix_cmp (const char *a
, const char *b
)
2837 riscv_isa_ext_class_t ca
= riscv_get_prefix_class (a
);
2838 riscv_isa_ext_class_t cb
= riscv_get_prefix_class (b
);
2840 /* Extension name without prefix */
2841 const char *anp
= riscv_skip_prefix (a
, ca
);
2842 const char *bnp
= riscv_skip_prefix (b
, cb
);
2845 return strcasecmp (anp
, bnp
);
2847 return (int)ca
- (int)cb
;
2850 /* Merge multi letter extensions. PIN is a pointer to the head of the input
2851 object subset list. Likewise for POUT and the output object. Return TRUE
2852 on success and FALSE when a conflict is found. */
2855 riscv_merge_multi_letter_ext (bfd
*ibfd
,
2856 riscv_subset_t
**pin
,
2857 riscv_subset_t
**pout
)
2859 riscv_subset_t
*in
= *pin
;
2860 riscv_subset_t
*out
= *pout
;
2861 riscv_subset_t
*tail
;
2867 cmp
= riscv_prefix_cmp (in
->name
, out
->name
);
2871 /* `in' comes before `out', append `in' and increment. */
2872 riscv_add_subset (&merged_subsets
, in
->name
, in
->major_version
,
2878 /* `out' comes before `in', append `out' and increment. */
2879 riscv_add_subset (&merged_subsets
, out
->name
, out
->major_version
,
2880 out
->minor_version
);
2885 /* Both present, check version and increment both. */
2886 if ((in
->major_version
!= out
->major_version
)
2887 || (in
->minor_version
!= out
->minor_version
))
2889 riscv_version_mismatch (ibfd
, in
, out
);
2893 riscv_add_subset (&merged_subsets
, out
->name
, out
->major_version
,
2894 out
->minor_version
);
2901 /* If we're here, either `in' or `out' is running longer than
2902 the other. So, we need to append the corresponding tail. */
2903 tail
= in
? in
: out
;
2907 riscv_add_subset (&merged_subsets
, tail
->name
, tail
->major_version
,
2908 tail
->minor_version
);
2916 /* Merge Tag_RISCV_arch attribute. */
2919 riscv_merge_arch_attr_info (bfd
*ibfd
, char *in_arch
, char *out_arch
)
2921 riscv_subset_t
*in
, *out
;
2922 char *merged_arch_str
;
2924 unsigned xlen_in
, xlen_out
;
2925 merged_subsets
.head
= NULL
;
2926 merged_subsets
.tail
= NULL
;
2928 riscv_parse_subset_t rpe_in
;
2929 riscv_parse_subset_t rpe_out
;
2931 /* Only assembler needs to check the default version of ISA, so just set
2932 the rpe_in.get_default_version and rpe_out.get_default_version to NULL. */
2933 rpe_in
.subset_list
= &in_subsets
;
2934 rpe_in
.error_handler
= _bfd_error_handler
;
2935 rpe_in
.xlen
= &xlen_in
;
2936 rpe_in
.get_default_version
= NULL
;
2938 rpe_out
.subset_list
= &out_subsets
;
2939 rpe_out
.error_handler
= _bfd_error_handler
;
2940 rpe_out
.xlen
= &xlen_out
;
2941 rpe_out
.get_default_version
= NULL
;
2943 if (in_arch
== NULL
&& out_arch
== NULL
)
2946 if (in_arch
== NULL
&& out_arch
!= NULL
)
2949 if (in_arch
!= NULL
&& out_arch
== NULL
)
2952 /* Parse subset from arch string. */
2953 if (!riscv_parse_subset (&rpe_in
, in_arch
))
2956 if (!riscv_parse_subset (&rpe_out
, out_arch
))
2959 /* Checking XLEN. */
2960 if (xlen_out
!= xlen_in
)
2963 (_("error: %pB: ISA string of input (%s) doesn't match "
2964 "output (%s)."), ibfd
, in_arch
, out_arch
);
2968 /* Merge subset list. */
2969 in
= in_subsets
.head
;
2970 out
= out_subsets
.head
;
2972 /* Merge standard extension. */
2973 if (!riscv_merge_std_ext (ibfd
, in_arch
, out_arch
, &in
, &out
))
2976 /* Merge all non-single letter extensions with single call. */
2977 if (!riscv_merge_multi_letter_ext (ibfd
, &in
, &out
))
2980 if (xlen_in
!= xlen_out
)
2983 (_("error: %pB: XLEN of input (%u) doesn't match "
2984 "output (%u)."), ibfd
, xlen_in
, xlen_out
);
2988 if (xlen_in
!= ARCH_SIZE
)
2991 (_("error: %pB: Unsupported XLEN (%u), you might be "
2992 "using wrong emulation."), ibfd
, xlen_in
);
2996 merged_arch_str
= riscv_arch_str (ARCH_SIZE
, &merged_subsets
);
2998 /* Release the subset lists. */
2999 riscv_release_subset_list (&in_subsets
);
3000 riscv_release_subset_list (&out_subsets
);
3001 riscv_release_subset_list (&merged_subsets
);
3003 return merged_arch_str
;
3006 /* Merge object attributes from IBFD into output_bfd of INFO.
3007 Raise an error if there are conflicting attributes. */
3010 riscv_merge_attributes (bfd
*ibfd
, struct bfd_link_info
*info
)
3012 bfd
*obfd
= info
->output_bfd
;
3013 obj_attribute
*in_attr
;
3014 obj_attribute
*out_attr
;
3015 bfd_boolean result
= TRUE
;
3016 const char *sec_name
= get_elf_backend_data (ibfd
)->obj_attrs_section
;
3019 /* Skip linker created files. */
3020 if (ibfd
->flags
& BFD_LINKER_CREATED
)
3023 /* Skip any input that doesn't have an attribute section.
3024 This enables to link object files without attribute section with
3026 if (bfd_get_section_by_name (ibfd
, sec_name
) == NULL
)
3029 if (!elf_known_obj_attributes_proc (obfd
)[0].i
)
3031 /* This is the first object. Copy the attributes. */
3032 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
3034 out_attr
= elf_known_obj_attributes_proc (obfd
);
3036 /* Use the Tag_null value to indicate the attributes have been
3043 in_attr
= elf_known_obj_attributes_proc (ibfd
);
3044 out_attr
= elf_known_obj_attributes_proc (obfd
);
3046 for (i
= LEAST_KNOWN_OBJ_ATTRIBUTE
; i
< NUM_KNOWN_OBJ_ATTRIBUTES
; i
++)
3050 case Tag_RISCV_arch
:
3051 if (!out_attr
[Tag_RISCV_arch
].s
)
3052 out_attr
[Tag_RISCV_arch
].s
= in_attr
[Tag_RISCV_arch
].s
;
3053 else if (in_attr
[Tag_RISCV_arch
].s
3054 && out_attr
[Tag_RISCV_arch
].s
)
3056 /* Check arch compatible. */
3058 riscv_merge_arch_attr_info (ibfd
,
3059 in_attr
[Tag_RISCV_arch
].s
,
3060 out_attr
[Tag_RISCV_arch
].s
);
3061 if (merged_arch
== NULL
)
3064 out_attr
[Tag_RISCV_arch
].s
= "";
3067 out_attr
[Tag_RISCV_arch
].s
= merged_arch
;
3070 case Tag_RISCV_priv_spec
:
3071 case Tag_RISCV_priv_spec_minor
:
3072 case Tag_RISCV_priv_spec_revision
:
3073 if (out_attr
[i
].i
!= in_attr
[i
].i
)
3076 (_("error: %pB: conflicting priv spec version "
3077 "(major/minor/revision)."), ibfd
);
3081 case Tag_RISCV_unaligned_access
:
3082 out_attr
[i
].i
|= in_attr
[i
].i
;
3084 case Tag_RISCV_stack_align
:
3085 if (out_attr
[i
].i
== 0)
3086 out_attr
[i
].i
= in_attr
[i
].i
;
3087 else if (in_attr
[i
].i
!= 0
3088 && out_attr
[i
].i
!= 0
3089 && out_attr
[i
].i
!= in_attr
[i
].i
)
3092 (_("error: %pB use %u-byte stack aligned but the output "
3093 "use %u-byte stack aligned."),
3094 ibfd
, in_attr
[i
].i
, out_attr
[i
].i
);
3099 result
&= _bfd_elf_merge_unknown_attribute_low (ibfd
, obfd
, i
);
3102 /* If out_attr was copied from in_attr then it won't have a type yet. */
3103 if (in_attr
[i
].type
&& !out_attr
[i
].type
)
3104 out_attr
[i
].type
= in_attr
[i
].type
;
3107 /* Merge Tag_compatibility attributes and any common GNU ones. */
3108 if (!_bfd_elf_merge_object_attributes (ibfd
, info
))
3111 /* Check for any attributes not known on RISC-V. */
3112 result
&= _bfd_elf_merge_unknown_attribute_list (ibfd
, obfd
);
3117 /* Merge backend specific data from an object file to the output
3118 object file when linking. */
3121 _bfd_riscv_elf_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
3123 bfd
*obfd
= info
->output_bfd
;
3124 flagword new_flags
, old_flags
;
3126 if (!is_riscv_elf (ibfd
) || !is_riscv_elf (obfd
))
3129 if (strcmp (bfd_get_target (ibfd
), bfd_get_target (obfd
)) != 0)
3131 (*_bfd_error_handler
)
3132 (_("%pB: ABI is incompatible with that of the selected emulation:\n"
3133 " target emulation `%s' does not match `%s'"),
3134 ibfd
, bfd_get_target (ibfd
), bfd_get_target (obfd
));
3138 if (!_bfd_elf_merge_object_attributes (ibfd
, info
))
3141 if (!riscv_merge_attributes (ibfd
, info
))
3144 new_flags
= elf_elfheader (ibfd
)->e_flags
;
3145 old_flags
= elf_elfheader (obfd
)->e_flags
;
3147 if (! elf_flags_init (obfd
))
3149 elf_flags_init (obfd
) = TRUE
;
3150 elf_elfheader (obfd
)->e_flags
= new_flags
;
3154 /* Check to see if the input BFD actually contains any sections. If not,
3155 its flags may not have been initialized either, but it cannot actually
3156 cause any incompatibility. Do not short-circuit dynamic objects; their
3157 section list may be emptied by elf_link_add_object_symbols.
3159 Also check to see if there are no code sections in the input. In this
3160 case, there is no need to check for code specific flags. */
3161 if (!(ibfd
->flags
& DYNAMIC
))
3163 bfd_boolean null_input_bfd
= TRUE
;
3164 bfd_boolean only_data_sections
= TRUE
;
3167 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
3169 if ((bfd_section_flags (sec
)
3170 & (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
3171 == (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
3172 only_data_sections
= FALSE
;
3174 null_input_bfd
= FALSE
;
3178 if (null_input_bfd
|| only_data_sections
)
3182 /* Disallow linking different float ABIs. */
3183 if ((old_flags
^ new_flags
) & EF_RISCV_FLOAT_ABI
)
3185 (*_bfd_error_handler
)
3186 (_("%pB: can't link %s modules with %s modules"), ibfd
,
3187 riscv_float_abi_string (new_flags
),
3188 riscv_float_abi_string (old_flags
));
3192 /* Disallow linking RVE and non-RVE. */
3193 if ((old_flags
^ new_flags
) & EF_RISCV_RVE
)
3195 (*_bfd_error_handler
)
3196 (_("%pB: can't link RVE with other target"), ibfd
);
3200 /* Allow linking RVC and non-RVC, and keep the RVC flag. */
3201 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_RISCV_RVC
;
3206 bfd_set_error (bfd_error_bad_value
);
3210 /* Delete some bytes from a section while relaxing. */
3213 riscv_relax_delete_bytes (bfd
*abfd
, asection
*sec
, bfd_vma addr
, size_t count
,
3214 struct bfd_link_info
*link_info
)
3216 unsigned int i
, symcount
;
3217 bfd_vma toaddr
= sec
->size
;
3218 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (abfd
);
3219 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3220 unsigned int sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
3221 struct bfd_elf_section_data
*data
= elf_section_data (sec
);
3222 bfd_byte
*contents
= data
->this_hdr
.contents
;
3224 /* Actually delete the bytes. */
3226 memmove (contents
+ addr
, contents
+ addr
+ count
, toaddr
- addr
- count
);
3228 /* Adjust the location of all of the relocs. Note that we need not
3229 adjust the addends, since all PC-relative references must be against
3230 symbols, which we will adjust below. */
3231 for (i
= 0; i
< sec
->reloc_count
; i
++)
3232 if (data
->relocs
[i
].r_offset
> addr
&& data
->relocs
[i
].r_offset
< toaddr
)
3233 data
->relocs
[i
].r_offset
-= count
;
3235 /* Adjust the local symbols defined in this section. */
3236 for (i
= 0; i
< symtab_hdr
->sh_info
; i
++)
3238 Elf_Internal_Sym
*sym
= (Elf_Internal_Sym
*) symtab_hdr
->contents
+ i
;
3239 if (sym
->st_shndx
== sec_shndx
)
3241 /* If the symbol is in the range of memory we just moved, we
3242 have to adjust its value. */
3243 if (sym
->st_value
> addr
&& sym
->st_value
<= toaddr
)
3244 sym
->st_value
-= count
;
3246 /* If the symbol *spans* the bytes we just deleted (i.e. its
3247 *end* is in the moved bytes but its *start* isn't), then we
3248 must adjust its size.
3250 This test needs to use the original value of st_value, otherwise
3251 we might accidentally decrease size when deleting bytes right
3252 before the symbol. But since deleted relocs can't span across
3253 symbols, we can't have both a st_value and a st_size decrease,
3254 so it is simpler to just use an else. */
3255 else if (sym
->st_value
<= addr
3256 && sym
->st_value
+ sym
->st_size
> addr
3257 && sym
->st_value
+ sym
->st_size
<= toaddr
)
3258 sym
->st_size
-= count
;
3262 /* Now adjust the global symbols defined in this section. */
3263 symcount
= ((symtab_hdr
->sh_size
/ sizeof (ElfNN_External_Sym
))
3264 - symtab_hdr
->sh_info
);
3266 for (i
= 0; i
< symcount
; i
++)
3268 struct elf_link_hash_entry
*sym_hash
= sym_hashes
[i
];
3270 /* The '--wrap SYMBOL' option is causing a pain when the object file,
3271 containing the definition of __wrap_SYMBOL, includes a direct
3272 call to SYMBOL as well. Since both __wrap_SYMBOL and SYMBOL reference
3273 the same symbol (which is __wrap_SYMBOL), but still exist as two
3274 different symbols in 'sym_hashes', we don't want to adjust
3275 the global symbol __wrap_SYMBOL twice. */
3276 /* The same problem occurs with symbols that are versioned_hidden, as
3277 foo becomes an alias for foo@BAR, and hence they need the same
3279 if (link_info
->wrap_hash
!= NULL
3280 || sym_hash
->versioned
== versioned_hidden
)
3282 struct elf_link_hash_entry
**cur_sym_hashes
;
3284 /* Loop only over the symbols which have already been checked. */
3285 for (cur_sym_hashes
= sym_hashes
; cur_sym_hashes
< &sym_hashes
[i
];
3288 /* If the current symbol is identical to 'sym_hash', that means
3289 the symbol was already adjusted (or at least checked). */
3290 if (*cur_sym_hashes
== sym_hash
)
3293 /* Don't adjust the symbol again. */
3294 if (cur_sym_hashes
< &sym_hashes
[i
])
3298 if ((sym_hash
->root
.type
== bfd_link_hash_defined
3299 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
3300 && sym_hash
->root
.u
.def
.section
== sec
)
3302 /* As above, adjust the value if needed. */
3303 if (sym_hash
->root
.u
.def
.value
> addr
3304 && sym_hash
->root
.u
.def
.value
<= toaddr
)
3305 sym_hash
->root
.u
.def
.value
-= count
;
3307 /* As above, adjust the size if needed. */
3308 else if (sym_hash
->root
.u
.def
.value
<= addr
3309 && sym_hash
->root
.u
.def
.value
+ sym_hash
->size
> addr
3310 && sym_hash
->root
.u
.def
.value
+ sym_hash
->size
<= toaddr
)
3311 sym_hash
->size
-= count
;
3318 /* A second format for recording PC-relative hi relocations. This stores the
3319 information required to relax them to GP-relative addresses. */
3321 typedef struct riscv_pcgp_hi_reloc riscv_pcgp_hi_reloc
;
3322 struct riscv_pcgp_hi_reloc
3329 bfd_boolean undefined_weak
;
3330 riscv_pcgp_hi_reloc
*next
;
3333 typedef struct riscv_pcgp_lo_reloc riscv_pcgp_lo_reloc
;
3334 struct riscv_pcgp_lo_reloc
3337 riscv_pcgp_lo_reloc
*next
;
3342 riscv_pcgp_hi_reloc
*hi
;
3343 riscv_pcgp_lo_reloc
*lo
;
3344 } riscv_pcgp_relocs
;
3346 /* Initialize the pcgp reloc info in P. */
3349 riscv_init_pcgp_relocs (riscv_pcgp_relocs
*p
)
3356 /* Free the pcgp reloc info in P. */
3359 riscv_free_pcgp_relocs (riscv_pcgp_relocs
*p
,
3360 bfd
*abfd ATTRIBUTE_UNUSED
,
3361 asection
*sec ATTRIBUTE_UNUSED
)
3363 riscv_pcgp_hi_reloc
*c
;
3364 riscv_pcgp_lo_reloc
*l
;
3366 for (c
= p
->hi
; c
!= NULL
;)
3368 riscv_pcgp_hi_reloc
*next
= c
->next
;
3373 for (l
= p
->lo
; l
!= NULL
;)
3375 riscv_pcgp_lo_reloc
*next
= l
->next
;
3381 /* Record pcgp hi part reloc info in P, using HI_SEC_OFF as the lookup index.
3382 The HI_ADDEND, HI_ADDR, HI_SYM, and SYM_SEC args contain info required to
3383 relax the corresponding lo part reloc. */
3386 riscv_record_pcgp_hi_reloc (riscv_pcgp_relocs
*p
, bfd_vma hi_sec_off
,
3387 bfd_vma hi_addend
, bfd_vma hi_addr
,
3388 unsigned hi_sym
, asection
*sym_sec
,
3389 bfd_boolean undefined_weak
)
3391 riscv_pcgp_hi_reloc
*new = bfd_malloc (sizeof(*new));
3394 new->hi_sec_off
= hi_sec_off
;
3395 new->hi_addend
= hi_addend
;
3396 new->hi_addr
= hi_addr
;
3397 new->hi_sym
= hi_sym
;
3398 new->sym_sec
= sym_sec
;
3399 new->undefined_weak
= undefined_weak
;
3405 /* Look up hi part pcgp reloc info in P, using HI_SEC_OFF as the lookup index.
3406 This is used by a lo part reloc to find the corresponding hi part reloc. */
3408 static riscv_pcgp_hi_reloc
*
3409 riscv_find_pcgp_hi_reloc(riscv_pcgp_relocs
*p
, bfd_vma hi_sec_off
)
3411 riscv_pcgp_hi_reloc
*c
;
3413 for (c
= p
->hi
; c
!= NULL
; c
= c
->next
)
3414 if (c
->hi_sec_off
== hi_sec_off
)
3419 /* Record pcgp lo part reloc info in P, using HI_SEC_OFF as the lookup info.
3420 This is used to record relocs that can't be relaxed. */
3423 riscv_record_pcgp_lo_reloc (riscv_pcgp_relocs
*p
, bfd_vma hi_sec_off
)
3425 riscv_pcgp_lo_reloc
*new = bfd_malloc (sizeof(*new));
3428 new->hi_sec_off
= hi_sec_off
;
3434 /* Look up lo part pcgp reloc info in P, using HI_SEC_OFF as the lookup index.
3435 This is used by a hi part reloc to find the corresponding lo part reloc. */
3438 riscv_find_pcgp_lo_reloc (riscv_pcgp_relocs
*p
, bfd_vma hi_sec_off
)
3440 riscv_pcgp_lo_reloc
*c
;
3442 for (c
= p
->lo
; c
!= NULL
; c
= c
->next
)
3443 if (c
->hi_sec_off
== hi_sec_off
)
3448 typedef bfd_boolean (*relax_func_t
) (bfd
*, asection
*, asection
*,
3449 struct bfd_link_info
*,
3450 Elf_Internal_Rela
*,
3451 bfd_vma
, bfd_vma
, bfd_vma
, bfd_boolean
*,
3452 riscv_pcgp_relocs
*,
3453 bfd_boolean undefined_weak
);
3455 /* Relax AUIPC + JALR into JAL. */
3458 _bfd_riscv_relax_call (bfd
*abfd
, asection
*sec
, asection
*sym_sec
,
3459 struct bfd_link_info
*link_info
,
3460 Elf_Internal_Rela
*rel
,
3462 bfd_vma max_alignment
,
3463 bfd_vma reserve_size ATTRIBUTE_UNUSED
,
3465 riscv_pcgp_relocs
*pcgp_relocs ATTRIBUTE_UNUSED
,
3466 bfd_boolean undefined_weak ATTRIBUTE_UNUSED
)
3468 bfd_byte
*contents
= elf_section_data (sec
)->this_hdr
.contents
;
3469 bfd_signed_vma foff
= symval
- (sec_addr (sec
) + rel
->r_offset
);
3470 bfd_boolean near_zero
= (symval
+ RISCV_IMM_REACH
/2) < RISCV_IMM_REACH
;
3471 bfd_vma auipc
, jalr
;
3472 int rd
, r_type
, len
= 4, rvc
= elf_elfheader (abfd
)->e_flags
& EF_RISCV_RVC
;
3474 /* If the call crosses section boundaries, an alignment directive could
3475 cause the PC-relative offset to later increase, so we need to add in the
3476 max alignment of any section inclusive from the call to the target.
3477 Otherwise, we only need to use the alignment of the current section. */
3478 if (VALID_UJTYPE_IMM (foff
))
3480 if (sym_sec
->output_section
== sec
->output_section
3481 && sym_sec
->output_section
!= bfd_abs_section_ptr
)
3482 max_alignment
= (bfd_vma
) 1 << sym_sec
->output_section
->alignment_power
;
3483 foff
+= (foff
< 0 ? -max_alignment
: max_alignment
);
3486 /* See if this function call can be shortened. */
3487 if (!VALID_UJTYPE_IMM (foff
) && !(!bfd_link_pic (link_info
) && near_zero
))
3490 /* Shorten the function call. */
3491 BFD_ASSERT (rel
->r_offset
+ 8 <= sec
->size
);
3493 auipc
= bfd_get_32 (abfd
, contents
+ rel
->r_offset
);
3494 jalr
= bfd_get_32 (abfd
, contents
+ rel
->r_offset
+ 4);
3495 rd
= (jalr
>> OP_SH_RD
) & OP_MASK_RD
;
3496 rvc
= rvc
&& VALID_RVC_J_IMM (foff
);
3498 /* C.J exists on RV32 and RV64, but C.JAL is RV32-only. */
3499 rvc
= rvc
&& (rd
== 0 || (rd
== X_RA
&& ARCH_SIZE
== 32));
3503 /* Relax to C.J[AL] rd, addr. */
3504 r_type
= R_RISCV_RVC_JUMP
;
3505 auipc
= rd
== 0 ? MATCH_C_J
: MATCH_C_JAL
;
3508 else if (VALID_UJTYPE_IMM (foff
))
3510 /* Relax to JAL rd, addr. */
3511 r_type
= R_RISCV_JAL
;
3512 auipc
= MATCH_JAL
| (rd
<< OP_SH_RD
);
3514 else /* near_zero */
3516 /* Relax to JALR rd, x0, addr. */
3517 r_type
= R_RISCV_LO12_I
;
3518 auipc
= MATCH_JALR
| (rd
<< OP_SH_RD
);
3521 /* Replace the R_RISCV_CALL reloc. */
3522 rel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (rel
->r_info
), r_type
);
3523 /* Replace the AUIPC. */
3524 bfd_put (8 * len
, abfd
, auipc
, contents
+ rel
->r_offset
);
3526 /* Delete unnecessary JALR. */
3528 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
+ len
, 8 - len
,
3532 /* Traverse all output sections and return the max alignment. */
3535 _bfd_riscv_get_max_alignment (asection
*sec
)
3537 unsigned int max_alignment_power
= 0;
3540 for (o
= sec
->output_section
->owner
->sections
; o
!= NULL
; o
= o
->next
)
3542 if (o
->alignment_power
> max_alignment_power
)
3543 max_alignment_power
= o
->alignment_power
;
3546 return (bfd_vma
) 1 << max_alignment_power
;
3549 /* Relax non-PIC global variable references. */
3552 _bfd_riscv_relax_lui (bfd
*abfd
,
3555 struct bfd_link_info
*link_info
,
3556 Elf_Internal_Rela
*rel
,
3558 bfd_vma max_alignment
,
3559 bfd_vma reserve_size
,
3561 riscv_pcgp_relocs
*pcgp_relocs ATTRIBUTE_UNUSED
,
3562 bfd_boolean undefined_weak
)
3564 bfd_byte
*contents
= elf_section_data (sec
)->this_hdr
.contents
;
3565 bfd_vma gp
= riscv_global_pointer_value (link_info
);
3566 int use_rvc
= elf_elfheader (abfd
)->e_flags
& EF_RISCV_RVC
;
3568 BFD_ASSERT (rel
->r_offset
+ 4 <= sec
->size
);
3572 /* If gp and the symbol are in the same output section, which is not the
3573 abs section, then consider only that output section's alignment. */
3574 struct bfd_link_hash_entry
*h
=
3575 bfd_link_hash_lookup (link_info
->hash
, RISCV_GP_SYMBOL
, FALSE
, FALSE
,
3577 if (h
->u
.def
.section
->output_section
== sym_sec
->output_section
3578 && sym_sec
->output_section
!= bfd_abs_section_ptr
)
3579 max_alignment
= (bfd_vma
) 1 << sym_sec
->output_section
->alignment_power
;
3582 /* Is the reference in range of x0 or gp?
3583 Valid gp range conservatively because of alignment issue. */
3585 || (VALID_ITYPE_IMM (symval
)
3587 && VALID_ITYPE_IMM (symval
- gp
+ max_alignment
+ reserve_size
))
3589 && VALID_ITYPE_IMM (symval
- gp
- max_alignment
- reserve_size
))))
3591 unsigned sym
= ELFNN_R_SYM (rel
->r_info
);
3592 switch (ELFNN_R_TYPE (rel
->r_info
))
3594 case R_RISCV_LO12_I
:
3597 /* Change the RS1 to zero. */
3598 bfd_vma insn
= bfd_get_32 (abfd
, contents
+ rel
->r_offset
);
3599 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
3600 bfd_put_32 (abfd
, insn
, contents
+ rel
->r_offset
);
3603 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_GPREL_I
);
3606 case R_RISCV_LO12_S
:
3609 /* Change the RS1 to zero. */
3610 bfd_vma insn
= bfd_get_32 (abfd
, contents
+ rel
->r_offset
);
3611 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
3612 bfd_put_32 (abfd
, insn
, contents
+ rel
->r_offset
);
3615 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_GPREL_S
);
3619 /* We can delete the unnecessary LUI and reloc. */
3620 rel
->r_info
= ELFNN_R_INFO (0, R_RISCV_NONE
);
3622 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
, 4,
3630 /* Can we relax LUI to C.LUI? Alignment might move the section forward;
3631 account for this assuming page alignment at worst. In the presence of
3632 RELRO segment the linker aligns it by one page size, therefore sections
3633 after the segment can be moved more than one page. */
3636 && ELFNN_R_TYPE (rel
->r_info
) == R_RISCV_HI20
3637 && VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (symval
))
3638 && VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (symval
)
3639 + (link_info
->relro
? 2 * ELF_MAXPAGESIZE
3640 : ELF_MAXPAGESIZE
)))
3642 /* Replace LUI with C.LUI if legal (i.e., rd != x0 and rd != x2/sp). */
3643 bfd_vma lui
= bfd_get_32 (abfd
, contents
+ rel
->r_offset
);
3644 unsigned rd
= ((unsigned)lui
>> OP_SH_RD
) & OP_MASK_RD
;
3645 if (rd
== 0 || rd
== X_SP
)
3648 lui
= (lui
& (OP_MASK_RD
<< OP_SH_RD
)) | MATCH_C_LUI
;
3649 bfd_put_32 (abfd
, lui
, contents
+ rel
->r_offset
);
3651 /* Replace the R_RISCV_HI20 reloc. */
3652 rel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (rel
->r_info
), R_RISCV_RVC_LUI
);
3655 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
+ 2, 2,
3662 /* Relax non-PIC TLS references. */
3665 _bfd_riscv_relax_tls_le (bfd
*abfd
,
3667 asection
*sym_sec ATTRIBUTE_UNUSED
,
3668 struct bfd_link_info
*link_info
,
3669 Elf_Internal_Rela
*rel
,
3671 bfd_vma max_alignment ATTRIBUTE_UNUSED
,
3672 bfd_vma reserve_size ATTRIBUTE_UNUSED
,
3674 riscv_pcgp_relocs
*prcel_relocs ATTRIBUTE_UNUSED
,
3675 bfd_boolean undefined_weak ATTRIBUTE_UNUSED
)
3677 /* See if this symbol is in range of tp. */
3678 if (RISCV_CONST_HIGH_PART (tpoff (link_info
, symval
)) != 0)
3681 BFD_ASSERT (rel
->r_offset
+ 4 <= sec
->size
);
3682 switch (ELFNN_R_TYPE (rel
->r_info
))
3684 case R_RISCV_TPREL_LO12_I
:
3685 rel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (rel
->r_info
), R_RISCV_TPREL_I
);
3688 case R_RISCV_TPREL_LO12_S
:
3689 rel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (rel
->r_info
), R_RISCV_TPREL_S
);
3692 case R_RISCV_TPREL_HI20
:
3693 case R_RISCV_TPREL_ADD
:
3694 /* We can delete the unnecessary instruction and reloc. */
3695 rel
->r_info
= ELFNN_R_INFO (0, R_RISCV_NONE
);
3697 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
, 4, link_info
);
3704 /* Implement R_RISCV_ALIGN by deleting excess alignment NOPs. */
3707 _bfd_riscv_relax_align (bfd
*abfd
, asection
*sec
,
3709 struct bfd_link_info
*link_info
,
3710 Elf_Internal_Rela
*rel
,
3712 bfd_vma max_alignment ATTRIBUTE_UNUSED
,
3713 bfd_vma reserve_size ATTRIBUTE_UNUSED
,
3714 bfd_boolean
*again ATTRIBUTE_UNUSED
,
3715 riscv_pcgp_relocs
*pcrel_relocs ATTRIBUTE_UNUSED
,
3716 bfd_boolean undefined_weak ATTRIBUTE_UNUSED
)
3718 bfd_byte
*contents
= elf_section_data (sec
)->this_hdr
.contents
;
3719 bfd_vma alignment
= 1, pos
;
3720 while (alignment
<= rel
->r_addend
)
3723 symval
-= rel
->r_addend
;
3724 bfd_vma aligned_addr
= ((symval
- 1) & ~(alignment
- 1)) + alignment
;
3725 bfd_vma nop_bytes
= aligned_addr
- symval
;
3727 /* Once we've handled an R_RISCV_ALIGN, we can't relax anything else. */
3728 sec
->sec_flg0
= TRUE
;
3730 /* Make sure there are enough NOPs to actually achieve the alignment. */
3731 if (rel
->r_addend
< nop_bytes
)
3734 (_("%pB(%pA+%#" PRIx64
"): %" PRId64
" bytes required for alignment "
3735 "to %" PRId64
"-byte boundary, but only %" PRId64
" present"),
3736 abfd
, sym_sec
, (uint64_t) rel
->r_offset
,
3737 (int64_t) nop_bytes
, (int64_t) alignment
, (int64_t) rel
->r_addend
);
3738 bfd_set_error (bfd_error_bad_value
);
3742 /* Delete the reloc. */
3743 rel
->r_info
= ELFNN_R_INFO (0, R_RISCV_NONE
);
3745 /* If the number of NOPs is already correct, there's nothing to do. */
3746 if (nop_bytes
== rel
->r_addend
)
3749 /* Write as many RISC-V NOPs as we need. */
3750 for (pos
= 0; pos
< (nop_bytes
& -4); pos
+= 4)
3751 bfd_put_32 (abfd
, RISCV_NOP
, contents
+ rel
->r_offset
+ pos
);
3753 /* Write a final RVC NOP if need be. */
3754 if (nop_bytes
% 4 != 0)
3755 bfd_put_16 (abfd
, RVC_NOP
, contents
+ rel
->r_offset
+ pos
);
3757 /* Delete the excess bytes. */
3758 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
+ nop_bytes
,
3759 rel
->r_addend
- nop_bytes
, link_info
);
3762 /* Relax PC-relative references to GP-relative references. */
3765 _bfd_riscv_relax_pc (bfd
*abfd ATTRIBUTE_UNUSED
,
3768 struct bfd_link_info
*link_info
,
3769 Elf_Internal_Rela
*rel
,
3771 bfd_vma max_alignment
,
3772 bfd_vma reserve_size
,
3773 bfd_boolean
*again ATTRIBUTE_UNUSED
,
3774 riscv_pcgp_relocs
*pcgp_relocs
,
3775 bfd_boolean undefined_weak
)
3777 bfd_byte
*contents
= elf_section_data (sec
)->this_hdr
.contents
;
3778 bfd_vma gp
= riscv_global_pointer_value (link_info
);
3780 BFD_ASSERT (rel
->r_offset
+ 4 <= sec
->size
);
3782 /* Chain the _LO relocs to their cooresponding _HI reloc to compute the
3783 * actual target address. */
3784 riscv_pcgp_hi_reloc hi_reloc
;
3785 memset (&hi_reloc
, 0, sizeof (hi_reloc
));
3786 switch (ELFNN_R_TYPE (rel
->r_info
))
3788 case R_RISCV_PCREL_LO12_I
:
3789 case R_RISCV_PCREL_LO12_S
:
3791 /* If the %lo has an addend, it isn't for the label pointing at the
3792 hi part instruction, but rather for the symbol pointed at by the
3793 hi part instruction. So we must subtract it here for the lookup.
3794 It is still used below in the final symbol address. */
3795 bfd_vma hi_sec_off
= symval
- sec_addr (sym_sec
) - rel
->r_addend
;
3796 riscv_pcgp_hi_reloc
*hi
= riscv_find_pcgp_hi_reloc (pcgp_relocs
,
3800 riscv_record_pcgp_lo_reloc (pcgp_relocs
, hi_sec_off
);
3805 symval
= hi_reloc
.hi_addr
;
3806 sym_sec
= hi_reloc
.sym_sec
;
3808 /* We can not know whether the undefined weak symbol is referenced
3809 according to the information of R_RISCV_PCREL_LO12_I/S. Therefore,
3810 we have to record the 'undefined_weak' flag when handling the
3811 corresponding R_RISCV_HI20 reloc in riscv_record_pcgp_hi_reloc. */
3812 undefined_weak
= hi_reloc
.undefined_weak
;
3816 case R_RISCV_PCREL_HI20
:
3817 /* Mergeable symbols and code might later move out of range. */
3818 if (! undefined_weak
3819 && sym_sec
->flags
& (SEC_MERGE
| SEC_CODE
))
3822 /* If the cooresponding lo relocation has already been seen then it's not
3823 * safe to relax this relocation. */
3824 if (riscv_find_pcgp_lo_reloc (pcgp_relocs
, rel
->r_offset
))
3835 /* If gp and the symbol are in the same output section, which is not the
3836 abs section, then consider only that output section's alignment. */
3837 struct bfd_link_hash_entry
*h
=
3838 bfd_link_hash_lookup (link_info
->hash
, RISCV_GP_SYMBOL
, FALSE
, FALSE
,
3840 if (h
->u
.def
.section
->output_section
== sym_sec
->output_section
3841 && sym_sec
->output_section
!= bfd_abs_section_ptr
)
3842 max_alignment
= (bfd_vma
) 1 << sym_sec
->output_section
->alignment_power
;
3845 /* Is the reference in range of x0 or gp?
3846 Valid gp range conservatively because of alignment issue. */
3848 || (VALID_ITYPE_IMM (symval
)
3850 && VALID_ITYPE_IMM (symval
- gp
+ max_alignment
+ reserve_size
))
3852 && VALID_ITYPE_IMM (symval
- gp
- max_alignment
- reserve_size
))))
3854 unsigned sym
= hi_reloc
.hi_sym
;
3855 switch (ELFNN_R_TYPE (rel
->r_info
))
3857 case R_RISCV_PCREL_LO12_I
:
3860 /* Change the RS1 to zero, and then modify the relocation
3861 type to R_RISCV_LO12_I. */
3862 bfd_vma insn
= bfd_get_32 (abfd
, contents
+ rel
->r_offset
);
3863 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
3864 bfd_put_32 (abfd
, insn
, contents
+ rel
->r_offset
);
3865 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_LO12_I
);
3866 rel
->r_addend
= hi_reloc
.hi_addend
;
3870 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_GPREL_I
);
3871 rel
->r_addend
+= hi_reloc
.hi_addend
;
3875 case R_RISCV_PCREL_LO12_S
:
3878 /* Change the RS1 to zero, and then modify the relocation
3879 type to R_RISCV_LO12_S. */
3880 bfd_vma insn
= bfd_get_32 (abfd
, contents
+ rel
->r_offset
);
3881 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
3882 bfd_put_32 (abfd
, insn
, contents
+ rel
->r_offset
);
3883 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_LO12_S
);
3884 rel
->r_addend
= hi_reloc
.hi_addend
;
3888 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_GPREL_S
);
3889 rel
->r_addend
+= hi_reloc
.hi_addend
;
3893 case R_RISCV_PCREL_HI20
:
3894 riscv_record_pcgp_hi_reloc (pcgp_relocs
,
3898 ELFNN_R_SYM(rel
->r_info
),
3901 /* We can delete the unnecessary AUIPC and reloc. */
3902 rel
->r_info
= ELFNN_R_INFO (0, R_RISCV_DELETE
);
3914 /* Relax PC-relative references to GP-relative references. */
3917 _bfd_riscv_relax_delete (bfd
*abfd
,
3919 asection
*sym_sec ATTRIBUTE_UNUSED
,
3920 struct bfd_link_info
*link_info
,
3921 Elf_Internal_Rela
*rel
,
3922 bfd_vma symval ATTRIBUTE_UNUSED
,
3923 bfd_vma max_alignment ATTRIBUTE_UNUSED
,
3924 bfd_vma reserve_size ATTRIBUTE_UNUSED
,
3925 bfd_boolean
*again ATTRIBUTE_UNUSED
,
3926 riscv_pcgp_relocs
*pcgp_relocs ATTRIBUTE_UNUSED
,
3927 bfd_boolean undefined_weak ATTRIBUTE_UNUSED
)
3929 if (!riscv_relax_delete_bytes(abfd
, sec
, rel
->r_offset
, rel
->r_addend
,
3932 rel
->r_info
= ELFNN_R_INFO(0, R_RISCV_NONE
);
3936 /* Relax a section. Pass 0 shortens code sequences unless disabled. Pass 1
3937 deletes the bytes that pass 0 made obselete. Pass 2, which cannot be
3938 disabled, handles code alignment directives. */
3941 _bfd_riscv_relax_section (bfd
*abfd
, asection
*sec
,
3942 struct bfd_link_info
*info
,
3945 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (abfd
);
3946 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
3947 struct bfd_elf_section_data
*data
= elf_section_data (sec
);
3948 Elf_Internal_Rela
*relocs
;
3949 bfd_boolean ret
= FALSE
;
3951 bfd_vma max_alignment
, reserve_size
= 0;
3952 riscv_pcgp_relocs pcgp_relocs
;
3956 if (bfd_link_relocatable (info
)
3958 || (sec
->flags
& SEC_RELOC
) == 0
3959 || sec
->reloc_count
== 0
3960 || (info
->disable_target_specific_optimizations
3961 && info
->relax_pass
== 0))
3964 riscv_init_pcgp_relocs (&pcgp_relocs
);
3966 /* Read this BFD's relocs if we haven't done so already. */
3968 relocs
= data
->relocs
;
3969 else if (!(relocs
= _bfd_elf_link_read_relocs (abfd
, sec
, NULL
, NULL
,
3970 info
->keep_memory
)))
3975 max_alignment
= htab
->max_alignment
;
3976 if (max_alignment
== (bfd_vma
) -1)
3978 max_alignment
= _bfd_riscv_get_max_alignment (sec
);
3979 htab
->max_alignment
= max_alignment
;
3983 max_alignment
= _bfd_riscv_get_max_alignment (sec
);
3985 /* Examine and consider relaxing each reloc. */
3986 for (i
= 0; i
< sec
->reloc_count
; i
++)
3989 Elf_Internal_Rela
*rel
= relocs
+ i
;
3990 relax_func_t relax_func
;
3991 int type
= ELFNN_R_TYPE (rel
->r_info
);
3994 bfd_boolean undefined_weak
= FALSE
;
3997 if (info
->relax_pass
== 0)
3999 if (type
== R_RISCV_CALL
|| type
== R_RISCV_CALL_PLT
)
4000 relax_func
= _bfd_riscv_relax_call
;
4001 else if (type
== R_RISCV_HI20
4002 || type
== R_RISCV_LO12_I
4003 || type
== R_RISCV_LO12_S
)
4004 relax_func
= _bfd_riscv_relax_lui
;
4005 else if (!bfd_link_pic(info
)
4006 && (type
== R_RISCV_PCREL_HI20
4007 || type
== R_RISCV_PCREL_LO12_I
4008 || type
== R_RISCV_PCREL_LO12_S
))
4009 relax_func
= _bfd_riscv_relax_pc
;
4010 else if (type
== R_RISCV_TPREL_HI20
4011 || type
== R_RISCV_TPREL_ADD
4012 || type
== R_RISCV_TPREL_LO12_I
4013 || type
== R_RISCV_TPREL_LO12_S
)
4014 relax_func
= _bfd_riscv_relax_tls_le
;
4018 /* Only relax this reloc if it is paired with R_RISCV_RELAX. */
4019 if (i
== sec
->reloc_count
- 1
4020 || ELFNN_R_TYPE ((rel
+ 1)->r_info
) != R_RISCV_RELAX
4021 || rel
->r_offset
!= (rel
+ 1)->r_offset
)
4024 /* Skip over the R_RISCV_RELAX. */
4027 else if (info
->relax_pass
== 1 && type
== R_RISCV_DELETE
)
4028 relax_func
= _bfd_riscv_relax_delete
;
4029 else if (info
->relax_pass
== 2 && type
== R_RISCV_ALIGN
)
4030 relax_func
= _bfd_riscv_relax_align
;
4034 data
->relocs
= relocs
;
4036 /* Read this BFD's contents if we haven't done so already. */
4037 if (!data
->this_hdr
.contents
4038 && !bfd_malloc_and_get_section (abfd
, sec
, &data
->this_hdr
.contents
))
4041 /* Read this BFD's symbols if we haven't done so already. */
4042 if (symtab_hdr
->sh_info
!= 0
4043 && !symtab_hdr
->contents
4044 && !(symtab_hdr
->contents
=
4045 (unsigned char *) bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
4046 symtab_hdr
->sh_info
,
4047 0, NULL
, NULL
, NULL
)))
4050 /* Get the value of the symbol referred to by the reloc. */
4051 if (ELFNN_R_SYM (rel
->r_info
) < symtab_hdr
->sh_info
)
4053 /* A local symbol. */
4054 Elf_Internal_Sym
*isym
= ((Elf_Internal_Sym
*) symtab_hdr
->contents
4055 + ELFNN_R_SYM (rel
->r_info
));
4056 reserve_size
= (isym
->st_size
- rel
->r_addend
) > isym
->st_size
4057 ? 0 : isym
->st_size
- rel
->r_addend
;
4059 if (isym
->st_shndx
== SHN_UNDEF
)
4060 sym_sec
= sec
, symval
= rel
->r_offset
;
4063 BFD_ASSERT (isym
->st_shndx
< elf_numsections (abfd
));
4064 sym_sec
= elf_elfsections (abfd
)[isym
->st_shndx
]->bfd_section
;
4066 /* The purpose of this code is unknown. It breaks linker scripts
4067 for embedded development that place sections at address zero.
4068 This code is believed to be unnecessary. Disabling it but not
4069 yet removing it, in case something breaks. */
4070 if (sec_addr (sym_sec
) == 0)
4073 symval
= isym
->st_value
;
4075 symtype
= ELF_ST_TYPE (isym
->st_info
);
4080 struct elf_link_hash_entry
*h
;
4082 indx
= ELFNN_R_SYM (rel
->r_info
) - symtab_hdr
->sh_info
;
4083 h
= elf_sym_hashes (abfd
)[indx
];
4085 while (h
->root
.type
== bfd_link_hash_indirect
4086 || h
->root
.type
== bfd_link_hash_warning
)
4087 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
4089 if (h
->root
.type
== bfd_link_hash_undefweak
4090 && (relax_func
== _bfd_riscv_relax_lui
4091 || relax_func
== _bfd_riscv_relax_pc
))
4093 /* For the lui and auipc relaxations, since the symbol
4094 value of an undefined weak symbol is always be zero,
4095 we can optimize the patterns into a single LI/MV/ADDI
4098 Note that, creating shared libraries and pie output may
4099 break the rule above. Fortunately, since we do not relax
4100 pc relocs when creating shared libraries and pie output,
4101 and the absolute address access for R_RISCV_HI20 isn't
4102 allowed when "-fPIC" is set, the problem of creating shared
4103 libraries can not happen currently. Once we support the
4104 auipc relaxations when creating shared libraries, then we will
4105 need the more rigorous checking for this optimization. */
4106 undefined_weak
= TRUE
;
4109 /* This line has to match the check in riscv_elf_relocate_section
4110 in the R_RISCV_CALL[_PLT] case. */
4111 if (bfd_link_pic (info
) && h
->plt
.offset
!= MINUS_ONE
)
4113 sym_sec
= htab
->elf
.splt
;
4114 symval
= h
->plt
.offset
;
4116 else if (undefined_weak
)
4119 sym_sec
= bfd_und_section_ptr
;
4121 else if ((h
->root
.type
== bfd_link_hash_defined
4122 || h
->root
.type
== bfd_link_hash_defweak
)
4123 && h
->root
.u
.def
.section
!= NULL
4124 && h
->root
.u
.def
.section
->output_section
!= NULL
)
4126 symval
= h
->root
.u
.def
.value
;
4127 sym_sec
= h
->root
.u
.def
.section
;
4132 if (h
->type
!= STT_FUNC
)
4134 (h
->size
- rel
->r_addend
) > h
->size
? 0 : h
->size
- rel
->r_addend
;
4138 if (sym_sec
->sec_info_type
== SEC_INFO_TYPE_MERGE
4139 && (sym_sec
->flags
& SEC_MERGE
))
4141 /* At this stage in linking, no SEC_MERGE symbol has been
4142 adjusted, so all references to such symbols need to be
4143 passed through _bfd_merged_section_offset. (Later, in
4144 relocate_section, all SEC_MERGE symbols *except* for
4145 section symbols have been adjusted.)
4147 gas may reduce relocations against symbols in SEC_MERGE
4148 sections to a relocation against the section symbol when
4149 the original addend was zero. When the reloc is against
4150 a section symbol we should include the addend in the
4151 offset passed to _bfd_merged_section_offset, since the
4152 location of interest is the original symbol. On the
4153 other hand, an access to "sym+addend" where "sym" is not
4154 a section symbol should not include the addend; Such an
4155 access is presumed to be an offset from "sym"; The
4156 location of interest is just "sym". */
4157 if (symtype
== STT_SECTION
)
4158 symval
+= rel
->r_addend
;
4160 symval
= _bfd_merged_section_offset (abfd
, &sym_sec
,
4161 elf_section_data (sym_sec
)->sec_info
,
4164 if (symtype
!= STT_SECTION
)
4165 symval
+= rel
->r_addend
;
4168 symval
+= rel
->r_addend
;
4170 symval
+= sec_addr (sym_sec
);
4172 if (!relax_func (abfd
, sec
, sym_sec
, info
, rel
, symval
,
4173 max_alignment
, reserve_size
, again
,
4174 &pcgp_relocs
, undefined_weak
))
4181 if (relocs
!= data
->relocs
)
4183 riscv_free_pcgp_relocs(&pcgp_relocs
, abfd
, sec
);
4189 # define PRSTATUS_SIZE 204
4190 # define PRSTATUS_OFFSET_PR_CURSIG 12
4191 # define PRSTATUS_OFFSET_PR_PID 24
4192 # define PRSTATUS_OFFSET_PR_REG 72
4193 # define ELF_GREGSET_T_SIZE 128
4194 # define PRPSINFO_SIZE 128
4195 # define PRPSINFO_OFFSET_PR_PID 16
4196 # define PRPSINFO_OFFSET_PR_FNAME 32
4197 # define PRPSINFO_OFFSET_PR_PSARGS 48
4199 # define PRSTATUS_SIZE 376
4200 # define PRSTATUS_OFFSET_PR_CURSIG 12
4201 # define PRSTATUS_OFFSET_PR_PID 32
4202 # define PRSTATUS_OFFSET_PR_REG 112
4203 # define ELF_GREGSET_T_SIZE 256
4204 # define PRPSINFO_SIZE 136
4205 # define PRPSINFO_OFFSET_PR_PID 24
4206 # define PRPSINFO_OFFSET_PR_FNAME 40
4207 # define PRPSINFO_OFFSET_PR_PSARGS 56
4210 /* Support for core dump NOTE sections. */
4213 riscv_elf_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
4215 switch (note
->descsz
)
4220 case PRSTATUS_SIZE
: /* sizeof(struct elf_prstatus) on Linux/RISC-V. */
4222 elf_tdata (abfd
)->core
->signal
4223 = bfd_get_16 (abfd
, note
->descdata
+ PRSTATUS_OFFSET_PR_CURSIG
);
4226 elf_tdata (abfd
)->core
->lwpid
4227 = bfd_get_32 (abfd
, note
->descdata
+ PRSTATUS_OFFSET_PR_PID
);
4231 /* Make a ".reg/999" section. */
4232 return _bfd_elfcore_make_pseudosection (abfd
, ".reg", ELF_GREGSET_T_SIZE
,
4233 note
->descpos
+ PRSTATUS_OFFSET_PR_REG
);
4237 riscv_elf_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
4239 switch (note
->descsz
)
4244 case PRPSINFO_SIZE
: /* sizeof(struct elf_prpsinfo) on Linux/RISC-V. */
4246 elf_tdata (abfd
)->core
->pid
4247 = bfd_get_32 (abfd
, note
->descdata
+ PRPSINFO_OFFSET_PR_PID
);
4250 elf_tdata (abfd
)->core
->program
= _bfd_elfcore_strndup
4251 (abfd
, note
->descdata
+ PRPSINFO_OFFSET_PR_FNAME
, 16);
4254 elf_tdata (abfd
)->core
->command
= _bfd_elfcore_strndup
4255 (abfd
, note
->descdata
+ PRPSINFO_OFFSET_PR_PSARGS
, 80);
4259 /* Note that for some reason, a spurious space is tacked
4260 onto the end of the args in some (at least one anyway)
4261 implementations, so strip it off if it exists. */
4264 char *command
= elf_tdata (abfd
)->core
->command
;
4265 int n
= strlen (command
);
4267 if (0 < n
&& command
[n
- 1] == ' ')
4268 command
[n
- 1] = '\0';
4274 /* Set the right mach type. */
4276 riscv_elf_object_p (bfd
*abfd
)
4278 /* There are only two mach types in RISCV currently. */
4279 if (strcmp (abfd
->xvec
->name
, "elf32-littleriscv") == 0)
4280 bfd_default_set_arch_mach (abfd
, bfd_arch_riscv
, bfd_mach_riscv32
);
4282 bfd_default_set_arch_mach (abfd
, bfd_arch_riscv
, bfd_mach_riscv64
);
4287 /* Determine whether an object attribute tag takes an integer, a
4291 riscv_elf_obj_attrs_arg_type (int tag
)
4293 return (tag
& 1) != 0 ? ATTR_TYPE_FLAG_STR_VAL
: ATTR_TYPE_FLAG_INT_VAL
;
4296 #define TARGET_LITTLE_SYM riscv_elfNN_vec
4297 #define TARGET_LITTLE_NAME "elfNN-littleriscv"
4299 #define elf_backend_reloc_type_class riscv_reloc_type_class
4301 #define bfd_elfNN_bfd_reloc_name_lookup riscv_reloc_name_lookup
4302 #define bfd_elfNN_bfd_link_hash_table_create riscv_elf_link_hash_table_create
4303 #define bfd_elfNN_bfd_reloc_type_lookup riscv_reloc_type_lookup
4304 #define bfd_elfNN_bfd_merge_private_bfd_data \
4305 _bfd_riscv_elf_merge_private_bfd_data
4307 #define elf_backend_copy_indirect_symbol riscv_elf_copy_indirect_symbol
4308 #define elf_backend_create_dynamic_sections riscv_elf_create_dynamic_sections
4309 #define elf_backend_check_relocs riscv_elf_check_relocs
4310 #define elf_backend_adjust_dynamic_symbol riscv_elf_adjust_dynamic_symbol
4311 #define elf_backend_size_dynamic_sections riscv_elf_size_dynamic_sections
4312 #define elf_backend_relocate_section riscv_elf_relocate_section
4313 #define elf_backend_finish_dynamic_symbol riscv_elf_finish_dynamic_symbol
4314 #define elf_backend_finish_dynamic_sections riscv_elf_finish_dynamic_sections
4315 #define elf_backend_gc_mark_hook riscv_elf_gc_mark_hook
4316 #define elf_backend_plt_sym_val riscv_elf_plt_sym_val
4317 #define elf_backend_grok_prstatus riscv_elf_grok_prstatus
4318 #define elf_backend_grok_psinfo riscv_elf_grok_psinfo
4319 #define elf_backend_object_p riscv_elf_object_p
4320 #define elf_info_to_howto_rel NULL
4321 #define elf_info_to_howto riscv_info_to_howto_rela
4322 #define bfd_elfNN_bfd_relax_section _bfd_riscv_relax_section
4323 #define bfd_elfNN_mkobject elfNN_riscv_mkobject
4325 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
4327 #define elf_backend_can_gc_sections 1
4328 #define elf_backend_can_refcount 1
4329 #define elf_backend_want_got_plt 1
4330 #define elf_backend_plt_readonly 1
4331 #define elf_backend_plt_alignment 4
4332 #define elf_backend_want_plt_sym 1
4333 #define elf_backend_got_header_size (ARCH_SIZE / 8)
4334 #define elf_backend_want_dynrelro 1
4335 #define elf_backend_rela_normal 1
4336 #define elf_backend_default_execstack 0
4338 #undef elf_backend_obj_attrs_vendor
4339 #define elf_backend_obj_attrs_vendor "riscv"
4340 #undef elf_backend_obj_attrs_arg_type
4341 #define elf_backend_obj_attrs_arg_type riscv_elf_obj_attrs_arg_type
4342 #undef elf_backend_obj_attrs_section_type
4343 #define elf_backend_obj_attrs_section_type SHT_RISCV_ATTRIBUTES
4344 #undef elf_backend_obj_attrs_section
4345 #define elf_backend_obj_attrs_section ".riscv.attributes"
4347 #include "elfNN-target.h"