1 /* RISC-V-specific support for NN-bit ELF.
2 Copyright (C) 2011-2021 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"
36 /* Internal relocations used exclusively by the relaxation pass. */
37 #define R_RISCV_DELETE (R_RISCV_max + 1)
41 #define MINUS_ONE ((bfd_vma)0 - 1)
43 #define RISCV_ELF_LOG_WORD_BYTES (ARCH_SIZE == 32 ? 2 : 3)
45 #define RISCV_ELF_WORD_BYTES (1 << RISCV_ELF_LOG_WORD_BYTES)
47 /* The name of the dynamic interpreter. This is put in the .interp
50 #define ELF64_DYNAMIC_INTERPRETER "/lib/ld.so.1"
51 #define ELF32_DYNAMIC_INTERPRETER "/lib32/ld.so.1"
53 #define ELF_ARCH bfd_arch_riscv
54 #define ELF_TARGET_ID RISCV_ELF_DATA
55 #define ELF_MACHINE_CODE EM_RISCV
56 #define ELF_MAXPAGESIZE 0x1000
57 #define ELF_COMMONPAGESIZE 0x1000
59 /* RISC-V ELF linker hash entry. */
61 struct riscv_elf_link_hash_entry
63 struct elf_link_hash_entry elf
;
73 #define riscv_elf_hash_entry(ent) \
74 ((struct riscv_elf_link_hash_entry *)(ent))
76 struct _bfd_riscv_elf_obj_tdata
78 struct elf_obj_tdata root
;
80 /* tls_type for each local got entry. */
81 char *local_got_tls_type
;
84 #define _bfd_riscv_elf_tdata(abfd) \
85 ((struct _bfd_riscv_elf_obj_tdata *) (abfd)->tdata.any)
87 #define _bfd_riscv_elf_local_got_tls_type(abfd) \
88 (_bfd_riscv_elf_tdata (abfd)->local_got_tls_type)
90 #define _bfd_riscv_elf_tls_type(abfd, h, symndx) \
91 (*((h) != NULL ? &riscv_elf_hash_entry (h)->tls_type \
92 : &_bfd_riscv_elf_local_got_tls_type (abfd) [symndx]))
94 #define is_riscv_elf(bfd) \
95 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
96 && elf_tdata (bfd) != NULL \
97 && elf_object_id (bfd) == RISCV_ELF_DATA)
100 elfNN_riscv_mkobject (bfd
*abfd
)
102 return bfd_elf_allocate_object (abfd
,
103 sizeof (struct _bfd_riscv_elf_obj_tdata
),
107 #include "elf/common.h"
108 #include "elf/internal.h"
110 struct riscv_elf_link_hash_table
112 struct elf_link_hash_table elf
;
114 /* Short-cuts to get to dynamic linker sections. */
117 /* The max alignment of output sections. */
118 bfd_vma max_alignment
;
120 /* Used by local STT_GNU_IFUNC symbols. */
121 htab_t loc_hash_table
;
122 void * loc_hash_memory
;
124 /* The index of the last unused .rel.iplt slot. */
125 bfd_vma last_iplt_index
;
129 /* Get the RISC-V ELF linker hash table from a link_info structure. */
130 #define riscv_elf_hash_table(p) \
131 ((is_elf_hash_table ((p)->hash) \
132 && elf_hash_table_id (elf_hash_table (p)) == RISCV_ELF_DATA) \
133 ? (struct riscv_elf_link_hash_table *) (p)->hash : NULL)
136 riscv_info_to_howto_rela (bfd
*abfd
,
138 Elf_Internal_Rela
*dst
)
140 cache_ptr
->howto
= riscv_elf_rtype_to_howto (abfd
, ELFNN_R_TYPE (dst
->r_info
));
141 return cache_ptr
->howto
!= NULL
;
145 riscv_elf_append_rela (bfd
*abfd
, asection
*s
, Elf_Internal_Rela
*rel
)
147 const struct elf_backend_data
*bed
;
150 bed
= get_elf_backend_data (abfd
);
151 loc
= s
->contents
+ (s
->reloc_count
++ * bed
->s
->sizeof_rela
);
152 bed
->s
->swap_reloca_out (abfd
, rel
, loc
);
157 #define PLT_HEADER_INSNS 8
158 #define PLT_ENTRY_INSNS 4
159 #define PLT_HEADER_SIZE (PLT_HEADER_INSNS * 4)
160 #define PLT_ENTRY_SIZE (PLT_ENTRY_INSNS * 4)
162 #define GOT_ENTRY_SIZE RISCV_ELF_WORD_BYTES
164 /* Reserve two entries of GOTPLT for ld.so, one is used for PLT resolver,
165 the other is used for link map. Other targets also reserve one more
166 entry used for runtime profile? */
167 #define GOTPLT_HEADER_SIZE (2 * GOT_ENTRY_SIZE)
169 #define sec_addr(sec) ((sec)->output_section->vma + (sec)->output_offset)
172 # define MATCH_LREG MATCH_LW
174 # define MATCH_LREG MATCH_LD
177 /* Generate a PLT header. */
180 riscv_make_plt_header (bfd
*output_bfd
, bfd_vma gotplt_addr
, bfd_vma addr
,
183 bfd_vma gotplt_offset_high
= RISCV_PCREL_HIGH_PART (gotplt_addr
, addr
);
184 bfd_vma gotplt_offset_low
= RISCV_PCREL_LOW_PART (gotplt_addr
, addr
);
186 /* RVE has no t3 register, so this won't work, and is not supported. */
187 if (elf_elfheader (output_bfd
)->e_flags
& EF_RISCV_RVE
)
189 _bfd_error_handler (_("%pB: warning: RVE PLT generation not supported"),
194 /* auipc t2, %hi(.got.plt)
195 sub t1, t1, t3 # shifted .got.plt offset + hdr size + 12
196 l[w|d] t3, %lo(.got.plt)(t2) # _dl_runtime_resolve
197 addi t1, t1, -(hdr size + 12) # shifted .got.plt offset
198 addi t0, t2, %lo(.got.plt) # &.got.plt
199 srli t1, t1, log2(16/PTRSIZE) # .got.plt offset
200 l[w|d] t0, PTRSIZE(t0) # link map
203 entry
[0] = RISCV_UTYPE (AUIPC
, X_T2
, gotplt_offset_high
);
204 entry
[1] = RISCV_RTYPE (SUB
, X_T1
, X_T1
, X_T3
);
205 entry
[2] = RISCV_ITYPE (LREG
, X_T3
, X_T2
, gotplt_offset_low
);
206 entry
[3] = RISCV_ITYPE (ADDI
, X_T1
, X_T1
, (uint32_t) -(PLT_HEADER_SIZE
+ 12));
207 entry
[4] = RISCV_ITYPE (ADDI
, X_T0
, X_T2
, gotplt_offset_low
);
208 entry
[5] = RISCV_ITYPE (SRLI
, X_T1
, X_T1
, 4 - RISCV_ELF_LOG_WORD_BYTES
);
209 entry
[6] = RISCV_ITYPE (LREG
, X_T0
, X_T0
, RISCV_ELF_WORD_BYTES
);
210 entry
[7] = RISCV_ITYPE (JALR
, 0, X_T3
, 0);
215 /* Generate a PLT entry. */
218 riscv_make_plt_entry (bfd
*output_bfd
, bfd_vma got
, bfd_vma addr
,
221 /* RVE has no t3 register, so this won't work, and is not supported. */
222 if (elf_elfheader (output_bfd
)->e_flags
& EF_RISCV_RVE
)
224 _bfd_error_handler (_("%pB: warning: RVE PLT generation not supported"),
229 /* auipc t3, %hi(.got.plt entry)
230 l[w|d] t3, %lo(.got.plt entry)(t3)
234 entry
[0] = RISCV_UTYPE (AUIPC
, X_T3
, RISCV_PCREL_HIGH_PART (got
, addr
));
235 entry
[1] = RISCV_ITYPE (LREG
, X_T3
, X_T3
, RISCV_PCREL_LOW_PART (got
, addr
));
236 entry
[2] = RISCV_ITYPE (JALR
, X_T1
, X_T3
, 0);
237 entry
[3] = RISCV_NOP
;
242 /* Create an entry in an RISC-V ELF linker hash table. */
244 static struct bfd_hash_entry
*
245 link_hash_newfunc (struct bfd_hash_entry
*entry
,
246 struct bfd_hash_table
*table
, const char *string
)
248 /* Allocate the structure if it has not already been allocated by a
253 bfd_hash_allocate (table
,
254 sizeof (struct riscv_elf_link_hash_entry
));
259 /* Call the allocation method of the superclass. */
260 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
263 struct riscv_elf_link_hash_entry
*eh
;
265 eh
= (struct riscv_elf_link_hash_entry
*) entry
;
266 eh
->tls_type
= GOT_UNKNOWN
;
272 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
273 for local symbol so that we can handle local STT_GNU_IFUNC symbols
274 as global symbol. We reuse indx and dynstr_index for local symbol
275 hash since they aren't used by global symbols in this backend. */
278 riscv_elf_local_htab_hash (const void *ptr
)
280 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*) ptr
;
281 return ELF_LOCAL_SYMBOL_HASH (h
->indx
, h
->dynstr_index
);
284 /* Compare local hash entries. */
287 riscv_elf_local_htab_eq (const void *ptr1
, const void *ptr2
)
289 struct elf_link_hash_entry
*h1
= (struct elf_link_hash_entry
*) ptr1
;
290 struct elf_link_hash_entry
*h2
= (struct elf_link_hash_entry
*) ptr2
;
292 return h1
->indx
== h2
->indx
&& h1
->dynstr_index
== h2
->dynstr_index
;
295 /* Find and/or create a hash entry for local symbol. */
297 static struct elf_link_hash_entry
*
298 riscv_elf_get_local_sym_hash (struct riscv_elf_link_hash_table
*htab
,
299 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
302 struct riscv_elf_link_hash_entry eh
, *ret
;
303 asection
*sec
= abfd
->sections
;
304 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
305 ELFNN_R_SYM (rel
->r_info
));
308 eh
.elf
.indx
= sec
->id
;
309 eh
.elf
.dynstr_index
= ELFNN_R_SYM (rel
->r_info
);
310 slot
= htab_find_slot_with_hash (htab
->loc_hash_table
, &eh
, h
,
311 create
? INSERT
: NO_INSERT
);
318 ret
= (struct riscv_elf_link_hash_entry
*) *slot
;
322 ret
= (struct riscv_elf_link_hash_entry
*)
323 objalloc_alloc ((struct objalloc
*) htab
->loc_hash_memory
,
324 sizeof (struct riscv_elf_link_hash_entry
));
327 memset (ret
, 0, sizeof (*ret
));
328 ret
->elf
.indx
= sec
->id
;
329 ret
->elf
.dynstr_index
= ELFNN_R_SYM (rel
->r_info
);
330 ret
->elf
.dynindx
= -1;
336 /* Destroy a RISC-V elf linker hash table. */
339 riscv_elf_link_hash_table_free (bfd
*obfd
)
341 struct riscv_elf_link_hash_table
*ret
342 = (struct riscv_elf_link_hash_table
*) obfd
->link
.hash
;
344 if (ret
->loc_hash_table
)
345 htab_delete (ret
->loc_hash_table
);
346 if (ret
->loc_hash_memory
)
347 objalloc_free ((struct objalloc
*) ret
->loc_hash_memory
);
349 _bfd_elf_link_hash_table_free (obfd
);
352 /* Create a RISC-V ELF linker hash table. */
354 static struct bfd_link_hash_table
*
355 riscv_elf_link_hash_table_create (bfd
*abfd
)
357 struct riscv_elf_link_hash_table
*ret
;
358 size_t amt
= sizeof (struct riscv_elf_link_hash_table
);
360 ret
= (struct riscv_elf_link_hash_table
*) bfd_zmalloc (amt
);
364 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
, link_hash_newfunc
,
365 sizeof (struct riscv_elf_link_hash_entry
),
372 ret
->max_alignment
= (bfd_vma
) -1;
374 /* Create hash table for local ifunc. */
375 ret
->loc_hash_table
= htab_try_create (1024,
376 riscv_elf_local_htab_hash
,
377 riscv_elf_local_htab_eq
,
379 ret
->loc_hash_memory
= objalloc_create ();
380 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
382 riscv_elf_link_hash_table_free (abfd
);
385 ret
->elf
.root
.hash_table_free
= riscv_elf_link_hash_table_free
;
387 return &ret
->elf
.root
;
390 /* Create the .got section. */
393 riscv_elf_create_got_section (bfd
*abfd
, struct bfd_link_info
*info
)
397 struct elf_link_hash_entry
*h
;
398 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
399 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
401 /* This function may be called more than once. */
402 if (htab
->sgot
!= NULL
)
405 flags
= bed
->dynamic_sec_flags
;
407 s
= bfd_make_section_anyway_with_flags (abfd
,
408 (bed
->rela_plts_and_copies_p
409 ? ".rela.got" : ".rel.got"),
410 (bed
->dynamic_sec_flags
413 || !bfd_set_section_alignment (s
, bed
->s
->log_file_align
))
417 s
= s_got
= bfd_make_section_anyway_with_flags (abfd
, ".got", flags
);
419 || !bfd_set_section_alignment (s
, bed
->s
->log_file_align
))
423 /* The first bit of the global offset table is the header. */
424 s
->size
+= bed
->got_header_size
;
426 if (bed
->want_got_plt
)
428 s
= bfd_make_section_anyway_with_flags (abfd
, ".got.plt", flags
);
430 || !bfd_set_section_alignment (s
, bed
->s
->log_file_align
))
434 /* Reserve room for the header. */
435 s
->size
+= GOTPLT_HEADER_SIZE
;
438 if (bed
->want_got_sym
)
440 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
441 section. We don't do this in the linker script because we don't want
442 to define the symbol if we are not creating a global offset
444 h
= _bfd_elf_define_linkage_sym (abfd
, info
, s_got
,
445 "_GLOBAL_OFFSET_TABLE_");
446 elf_hash_table (info
)->hgot
= h
;
454 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
455 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
459 riscv_elf_create_dynamic_sections (bfd
*dynobj
,
460 struct bfd_link_info
*info
)
462 struct riscv_elf_link_hash_table
*htab
;
464 htab
= riscv_elf_hash_table (info
);
465 BFD_ASSERT (htab
!= NULL
);
467 if (!riscv_elf_create_got_section (dynobj
, info
))
470 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
473 if (!bfd_link_pic (info
))
475 /* Technically, this section doesn't have contents. It is used as the
476 target of TLS copy relocs, to copy TLS data from shared libraries into
477 the executable. However, if we don't mark it as loadable, then it
478 matches the IS_TBSS test in ldlang.c, and there is no run-time address
479 space allocated for it even though it has SEC_ALLOC. That test is
480 correct for .tbss, but not correct for this section. There is also
481 a second problem that having a section with no contents can only work
482 if it comes after all sections with contents in the same segment,
483 but the linker script does not guarantee that. This is just mixed in
484 with other .tdata.* sections. We can fix both problems by lying and
485 saying that there are contents. This section is expected to be small
486 so this should not cause a significant extra program startup cost. */
488 bfd_make_section_anyway_with_flags (dynobj
, ".tdata.dyn",
489 (SEC_ALLOC
| SEC_THREAD_LOCAL
490 | SEC_LOAD
| SEC_DATA
492 | SEC_LINKER_CREATED
));
495 if (!htab
->elf
.splt
|| !htab
->elf
.srelplt
|| !htab
->elf
.sdynbss
496 || (!bfd_link_pic (info
) && (!htab
->elf
.srelbss
|| !htab
->sdyntdata
)))
502 /* Copy the extra info we tack onto an elf_link_hash_entry. */
505 riscv_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
506 struct elf_link_hash_entry
*dir
,
507 struct elf_link_hash_entry
*ind
)
509 struct riscv_elf_link_hash_entry
*edir
, *eind
;
511 edir
= (struct riscv_elf_link_hash_entry
*) dir
;
512 eind
= (struct riscv_elf_link_hash_entry
*) ind
;
514 if (ind
->root
.type
== bfd_link_hash_indirect
515 && dir
->got
.refcount
<= 0)
517 edir
->tls_type
= eind
->tls_type
;
518 eind
->tls_type
= GOT_UNKNOWN
;
520 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
524 riscv_elf_record_tls_type (bfd
*abfd
, struct elf_link_hash_entry
*h
,
525 unsigned long symndx
, char tls_type
)
527 char *new_tls_type
= &_bfd_riscv_elf_tls_type (abfd
, h
, symndx
);
529 *new_tls_type
|= tls_type
;
530 if ((*new_tls_type
& GOT_NORMAL
) && (*new_tls_type
& ~GOT_NORMAL
))
532 (*_bfd_error_handler
)
533 (_("%pB: `%s' accessed both as normal and thread local symbol"),
534 abfd
, h
? h
->root
.root
.string
: "<local>");
541 riscv_elf_record_got_reference (bfd
*abfd
, struct bfd_link_info
*info
,
542 struct elf_link_hash_entry
*h
, long symndx
)
544 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
545 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
547 if (htab
->elf
.sgot
== NULL
)
549 if (!riscv_elf_create_got_section (htab
->elf
.dynobj
, info
))
555 h
->got
.refcount
+= 1;
559 /* This is a global offset table entry for a local symbol. */
560 if (elf_local_got_refcounts (abfd
) == NULL
)
562 bfd_size_type size
= symtab_hdr
->sh_info
* (sizeof (bfd_vma
) + 1);
563 if (!(elf_local_got_refcounts (abfd
) = bfd_zalloc (abfd
, size
)))
565 _bfd_riscv_elf_local_got_tls_type (abfd
)
566 = (char *) (elf_local_got_refcounts (abfd
) + symtab_hdr
->sh_info
);
568 elf_local_got_refcounts (abfd
) [symndx
] += 1;
574 bad_static_reloc (bfd
*abfd
, unsigned r_type
, struct elf_link_hash_entry
*h
)
576 reloc_howto_type
* r
= riscv_elf_rtype_to_howto (abfd
, r_type
);
578 /* We propably can improve the information to tell users that they
579 should be recompile the code with -fPIC or -fPIE, just like what
581 (*_bfd_error_handler
)
582 (_("%pB: relocation %s against `%s' can not be used when making a shared "
583 "object; recompile with -fPIC"),
584 abfd
, r
? r
->name
: _("<unknown>"),
585 h
!= NULL
? h
->root
.root
.string
: "a local symbol");
586 bfd_set_error (bfd_error_bad_value
);
589 /* Look through the relocs for a section during the first phase, and
590 allocate space in the global offset table or procedure linkage
594 riscv_elf_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
595 asection
*sec
, const Elf_Internal_Rela
*relocs
)
597 struct riscv_elf_link_hash_table
*htab
;
598 Elf_Internal_Shdr
*symtab_hdr
;
599 struct elf_link_hash_entry
**sym_hashes
;
600 const Elf_Internal_Rela
*rel
;
601 asection
*sreloc
= NULL
;
603 if (bfd_link_relocatable (info
))
606 htab
= riscv_elf_hash_table (info
);
607 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
608 sym_hashes
= elf_sym_hashes (abfd
);
610 if (htab
->elf
.dynobj
== NULL
)
611 htab
->elf
.dynobj
= abfd
;
613 for (rel
= relocs
; rel
< relocs
+ sec
->reloc_count
; rel
++)
616 unsigned int r_symndx
;
617 struct elf_link_hash_entry
*h
;
619 r_symndx
= ELFNN_R_SYM (rel
->r_info
);
620 r_type
= ELFNN_R_TYPE (rel
->r_info
);
622 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
624 (*_bfd_error_handler
) (_("%pB: bad symbol index: %d"),
629 if (r_symndx
< symtab_hdr
->sh_info
)
631 /* A local symbol. */
632 Elf_Internal_Sym
*isym
= bfd_sym_from_r_symndx (&htab
->elf
.sym_cache
,
637 /* Check relocation against local STT_GNU_IFUNC symbol. */
638 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
640 h
= riscv_elf_get_local_sym_hash (htab
, abfd
, rel
, TRUE
);
644 /* Fake STT_GNU_IFUNC global symbol. */
645 h
->root
.root
.string
= bfd_elf_sym_name (abfd
, symtab_hdr
,
647 h
->type
= STT_GNU_IFUNC
;
651 h
->root
.type
= bfd_link_hash_defined
;
658 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
659 while (h
->root
.type
== bfd_link_hash_indirect
660 || h
->root
.type
== bfd_link_hash_warning
)
661 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
671 case R_RISCV_CALL_PLT
:
673 case R_RISCV_GOT_HI20
:
674 case R_RISCV_PCREL_HI20
:
675 /* Create the ifunc sections, iplt and ipltgot, for static
677 if (h
->type
== STT_GNU_IFUNC
678 && !_bfd_elf_create_ifunc_sections (htab
->elf
.dynobj
, info
))
686 /* It is referenced by a non-shared object. */
692 case R_RISCV_TLS_GD_HI20
:
693 if (!riscv_elf_record_got_reference (abfd
, info
, h
, r_symndx
)
694 || !riscv_elf_record_tls_type (abfd
, h
, r_symndx
, GOT_TLS_GD
))
698 case R_RISCV_TLS_GOT_HI20
:
699 if (bfd_link_pic (info
))
700 info
->flags
|= DF_STATIC_TLS
;
701 if (!riscv_elf_record_got_reference (abfd
, info
, h
, r_symndx
)
702 || !riscv_elf_record_tls_type (abfd
, h
, r_symndx
, GOT_TLS_IE
))
706 case R_RISCV_GOT_HI20
:
707 if (!riscv_elf_record_got_reference (abfd
, info
, h
, r_symndx
)
708 || !riscv_elf_record_tls_type (abfd
, h
, r_symndx
, GOT_NORMAL
))
713 case R_RISCV_CALL_PLT
:
714 /* These symbol requires a procedure linkage table entry. We
715 actually build the entry in adjust_dynamic_symbol,
716 because these might be a case of linking PIC code without
717 linking in any dynamic objects, in which case we don't
718 need to generate a procedure linkage table after all. */
720 /* If it is a local symbol, then we resolve it directly
721 without creating a PLT entry. */
726 h
->plt
.refcount
+= 1;
729 case R_RISCV_PCREL_HI20
:
731 && h
->type
== STT_GNU_IFUNC
)
734 h
->pointer_equality_needed
= 1;
736 /* We don't use the PCREL_HI20 in the data section,
737 so we always need the plt when it refers to
739 h
->plt
.refcount
+= 1;
745 case R_RISCV_RVC_BRANCH
:
746 case R_RISCV_RVC_JUMP
:
747 /* In shared libraries and pie, these relocs are known
749 if (bfd_link_pic (info
))
753 case R_RISCV_TPREL_HI20
:
754 if (!bfd_link_executable (info
))
755 return bad_static_reloc (abfd
, r_type
, h
);
757 riscv_elf_record_tls_type (abfd
, h
, r_symndx
, GOT_TLS_LE
);
761 if (bfd_link_pic (info
))
762 return bad_static_reloc (abfd
, r_type
, h
);
766 case R_RISCV_JUMP_SLOT
:
767 case R_RISCV_RELATIVE
:
775 && (!bfd_link_pic (info
)
776 || h
->type
== STT_GNU_IFUNC
))
778 /* This reloc might not bind locally. */
780 h
->pointer_equality_needed
= 1;
783 || (sec
->flags
& (SEC_CODE
| SEC_READONLY
)) != 0)
785 /* We may need a .plt entry if the symbol is a function
786 defined in a shared lib or is a function referenced
787 from the code or read-only section. */
788 h
->plt
.refcount
+= 1;
792 /* If we are creating a shared library, and this is a reloc
793 against a global symbol, or a non PC relative reloc
794 against a local symbol, then we need to copy the reloc
795 into the shared library. However, if we are linking with
796 -Bsymbolic, we do not need to copy a reloc against a
797 global symbol which is defined in an object we are
798 including in the link (i.e., DEF_REGULAR is set). At
799 this point we have not seen all the input files, so it is
800 possible that DEF_REGULAR is not set now but will be set
801 later (it is never cleared). In case of a weak definition,
802 DEF_REGULAR may be cleared later by a strong definition in
803 a shared library. We account for that possibility below by
804 storing information in the relocs_copied field of the hash
805 table entry. A similar situation occurs when creating
806 shared libraries and symbol visibility changes render the
809 If on the other hand, we are creating an executable, we
810 may need to keep relocations for symbols satisfied by a
811 dynamic library if we manage to avoid copy relocs for the
814 Generate dynamic pointer relocation against STT_GNU_IFUNC
815 symbol in the non-code section (R_RISCV_32/R_RISCV_64). */
816 reloc_howto_type
* r
= riscv_elf_rtype_to_howto (abfd
, r_type
);
818 if ((bfd_link_pic (info
)
819 && (sec
->flags
& SEC_ALLOC
) != 0
820 && ((r
!= NULL
&& !r
->pc_relative
)
823 || h
->root
.type
== bfd_link_hash_defweak
824 || !h
->def_regular
))))
825 || (!bfd_link_pic (info
)
826 && (sec
->flags
& SEC_ALLOC
) != 0
828 && (h
->root
.type
== bfd_link_hash_defweak
830 || (!bfd_link_pic (info
)
832 && h
->type
== STT_GNU_IFUNC
833 && (sec
->flags
& SEC_CODE
) == 0))
835 struct elf_dyn_relocs
*p
;
836 struct elf_dyn_relocs
**head
;
838 /* When creating a shared object, we must copy these
839 relocs into the output file. We create a reloc
840 section in dynobj and make room for the reloc. */
843 sreloc
= _bfd_elf_make_dynamic_reloc_section
844 (sec
, htab
->elf
.dynobj
, RISCV_ELF_LOG_WORD_BYTES
,
845 abfd
, /*rela?*/ TRUE
);
851 /* If this is a global symbol, we count the number of
852 relocations we need for this symbol. */
854 head
= &h
->dyn_relocs
;
857 /* Track dynamic relocs needed for local syms too.
858 We really need local syms available to do this
863 Elf_Internal_Sym
*isym
;
865 isym
= bfd_sym_from_r_symndx (&htab
->elf
.sym_cache
,
870 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
874 vpp
= &elf_section_data (s
)->local_dynrel
;
875 head
= (struct elf_dyn_relocs
**) vpp
;
879 if (p
== NULL
|| p
->sec
!= sec
)
881 size_t amt
= sizeof *p
;
882 p
= ((struct elf_dyn_relocs
*)
883 bfd_alloc (htab
->elf
.dynobj
, amt
));
894 p
->pc_count
+= r
== NULL
? 0 : r
->pc_relative
;
899 case R_RISCV_GNU_VTINHERIT
:
900 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
904 case R_RISCV_GNU_VTENTRY
:
905 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
918 riscv_elf_gc_mark_hook (asection
*sec
,
919 struct bfd_link_info
*info
,
920 Elf_Internal_Rela
*rel
,
921 struct elf_link_hash_entry
*h
,
922 Elf_Internal_Sym
*sym
)
925 switch (ELFNN_R_TYPE (rel
->r_info
))
927 case R_RISCV_GNU_VTINHERIT
:
928 case R_RISCV_GNU_VTENTRY
:
932 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
935 /* Adjust a symbol defined by a dynamic object and referenced by a
936 regular object. The current definition is in some section of the
937 dynamic object, but we're not including those sections. We have to
938 change the definition to something the rest of the link can
942 riscv_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
943 struct elf_link_hash_entry
*h
)
945 struct riscv_elf_link_hash_table
*htab
;
946 struct riscv_elf_link_hash_entry
* eh
;
950 htab
= riscv_elf_hash_table (info
);
951 BFD_ASSERT (htab
!= NULL
);
953 dynobj
= htab
->elf
.dynobj
;
955 /* Make sure we know what is going on here. */
956 BFD_ASSERT (dynobj
!= NULL
958 || h
->type
== STT_GNU_IFUNC
962 && !h
->def_regular
)));
964 /* If this is a function, put it in the procedure linkage table. We
965 will fill in the contents of the procedure linkage table later
966 (although we could actually do it here). */
967 if (h
->type
== STT_FUNC
|| h
->type
== STT_GNU_IFUNC
|| h
->needs_plt
)
969 if (h
->plt
.refcount
<= 0
970 || (h
->type
!= STT_GNU_IFUNC
971 && (SYMBOL_CALLS_LOCAL (info
, h
)
972 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
973 && h
->root
.type
== bfd_link_hash_undefweak
))))
975 /* This case can occur if we saw a R_RISCV_CALL_PLT reloc in an
976 input file, but the symbol was never referred to by a dynamic
977 object, or if all references were garbage collected. In such
978 a case, we don't actually need to build a PLT entry. */
979 h
->plt
.offset
= (bfd_vma
) -1;
986 h
->plt
.offset
= (bfd_vma
) -1;
988 /* If this is a weak symbol, and there is a real definition, the
989 processor independent code will have arranged for us to see the
990 real definition first, and we can just use the same value. */
993 struct elf_link_hash_entry
*def
= weakdef (h
);
994 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
995 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
996 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
1000 /* This is a reference to a symbol defined by a dynamic object which
1001 is not a function. */
1003 /* If we are creating a shared library, we must presume that the
1004 only references to the symbol are via the global offset table.
1005 For such cases we need not do anything here; the relocations will
1006 be handled correctly by relocate_section. */
1007 if (bfd_link_pic (info
))
1010 /* If there are no references to this symbol that do not use the
1011 GOT, we don't need to generate a copy reloc. */
1012 if (!h
->non_got_ref
)
1015 /* If -z nocopyreloc was given, we won't generate them either. */
1016 if (info
->nocopyreloc
)
1022 /* If we don't find any dynamic relocs in read-only sections, then
1023 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1024 if (!_bfd_elf_readonly_dynrelocs (h
))
1030 /* We must allocate the symbol in our .dynbss section, which will
1031 become part of the .bss section of the executable. There will be
1032 an entry for this symbol in the .dynsym section. The dynamic
1033 object will contain position independent code, so all references
1034 from the dynamic object to this symbol will go through the global
1035 offset table. The dynamic linker will use the .dynsym entry to
1036 determine the address it must put in the global offset table, so
1037 both the dynamic object and the regular object will refer to the
1038 same memory location for the variable. */
1040 /* We must generate a R_RISCV_COPY reloc to tell the dynamic linker
1041 to copy the initial value out of the dynamic object and into the
1042 runtime process image. We need to remember the offset into the
1043 .rel.bss section we are going to use. */
1044 eh
= (struct riscv_elf_link_hash_entry
*) h
;
1045 if (eh
->tls_type
& ~GOT_NORMAL
)
1047 s
= htab
->sdyntdata
;
1048 srel
= htab
->elf
.srelbss
;
1050 else if ((h
->root
.u
.def
.section
->flags
& SEC_READONLY
) != 0)
1052 s
= htab
->elf
.sdynrelro
;
1053 srel
= htab
->elf
.sreldynrelro
;
1057 s
= htab
->elf
.sdynbss
;
1058 srel
= htab
->elf
.srelbss
;
1060 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
1062 srel
->size
+= sizeof (ElfNN_External_Rela
);
1066 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
1069 /* Allocate space in .plt, .got and associated reloc sections for
1073 allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
1075 struct bfd_link_info
*info
;
1076 struct riscv_elf_link_hash_table
*htab
;
1077 struct elf_dyn_relocs
*p
;
1079 if (h
->root
.type
== bfd_link_hash_indirect
)
1082 info
= (struct bfd_link_info
*) inf
;
1083 htab
= riscv_elf_hash_table (info
);
1084 BFD_ASSERT (htab
!= NULL
);
1086 /* Since STT_GNU_IFUNC symbols must go through PLT, we handle them
1087 in the allocate_ifunc_dynrelocs and allocate_local_ifunc_dynrelocs,
1088 if they are defined and referenced in a non-shared object. */
1089 if (h
->type
== STT_GNU_IFUNC
1092 else if (htab
->elf
.dynamic_sections_created
1093 && h
->plt
.refcount
> 0)
1095 /* Make sure this symbol is output as a dynamic symbol.
1096 Undefined weak syms won't yet be marked as dynamic. */
1097 if (h
->dynindx
== -1
1098 && !h
->forced_local
)
1100 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1104 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info
), h
))
1106 asection
*s
= htab
->elf
.splt
;
1109 s
->size
= PLT_HEADER_SIZE
;
1111 h
->plt
.offset
= s
->size
;
1113 /* Make room for this entry. */
1114 s
->size
+= PLT_ENTRY_SIZE
;
1116 /* We also need to make an entry in the .got.plt section. */
1117 htab
->elf
.sgotplt
->size
+= GOT_ENTRY_SIZE
;
1119 /* We also need to make an entry in the .rela.plt section. */
1120 htab
->elf
.srelplt
->size
+= sizeof (ElfNN_External_Rela
);
1122 /* If this symbol is not defined in a regular file, and we are
1123 not generating a shared library, then set the symbol to this
1124 location in the .plt. This is required to make function
1125 pointers compare as equal between the normal executable and
1126 the shared library. */
1127 if (! bfd_link_pic (info
)
1130 h
->root
.u
.def
.section
= s
;
1131 h
->root
.u
.def
.value
= h
->plt
.offset
;
1136 h
->plt
.offset
= (bfd_vma
) -1;
1142 h
->plt
.offset
= (bfd_vma
) -1;
1146 if (h
->got
.refcount
> 0)
1150 int tls_type
= riscv_elf_hash_entry (h
)->tls_type
;
1152 /* Make sure this symbol is output as a dynamic symbol.
1153 Undefined weak syms won't yet be marked as dynamic. */
1154 if (h
->dynindx
== -1
1155 && !h
->forced_local
)
1157 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1162 h
->got
.offset
= s
->size
;
1163 dyn
= htab
->elf
.dynamic_sections_created
;
1164 if (tls_type
& (GOT_TLS_GD
| GOT_TLS_IE
))
1166 /* TLS_GD needs two dynamic relocs and two GOT slots. */
1167 if (tls_type
& GOT_TLS_GD
)
1169 s
->size
+= 2 * RISCV_ELF_WORD_BYTES
;
1170 htab
->elf
.srelgot
->size
+= 2 * sizeof (ElfNN_External_Rela
);
1173 /* TLS_IE needs one dynamic reloc and one GOT slot. */
1174 if (tls_type
& GOT_TLS_IE
)
1176 s
->size
+= RISCV_ELF_WORD_BYTES
;
1177 htab
->elf
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
1182 s
->size
+= RISCV_ELF_WORD_BYTES
;
1183 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, bfd_link_pic (info
), h
)
1184 && ! UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
1185 htab
->elf
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
1189 h
->got
.offset
= (bfd_vma
) -1;
1191 if (h
->dyn_relocs
== NULL
)
1194 /* In the shared -Bsymbolic case, discard space allocated for
1195 dynamic pc-relative relocs against symbols which turn out to be
1196 defined in regular objects. For the normal shared case, discard
1197 space for pc-relative relocs that have become local due to symbol
1198 visibility changes. */
1200 if (bfd_link_pic (info
))
1202 if (SYMBOL_CALLS_LOCAL (info
, h
))
1204 struct elf_dyn_relocs
**pp
;
1206 for (pp
= &h
->dyn_relocs
; (p
= *pp
) != NULL
; )
1208 p
->count
-= p
->pc_count
;
1217 /* Also discard relocs on undefined weak syms with non-default
1219 if (h
->dyn_relocs
!= NULL
1220 && h
->root
.type
== bfd_link_hash_undefweak
)
1222 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
1223 || UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
1224 h
->dyn_relocs
= NULL
;
1226 /* Make sure undefined weak symbols are output as a dynamic
1228 else if (h
->dynindx
== -1
1229 && !h
->forced_local
)
1231 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1238 /* For the non-shared case, discard space for relocs against
1239 symbols which turn out to need copy relocs or are not
1245 || (htab
->elf
.dynamic_sections_created
1246 && (h
->root
.type
== bfd_link_hash_undefweak
1247 || h
->root
.type
== bfd_link_hash_undefined
))))
1249 /* Make sure this symbol is output as a dynamic symbol.
1250 Undefined weak syms won't yet be marked as dynamic. */
1251 if (h
->dynindx
== -1
1252 && !h
->forced_local
)
1254 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1258 /* If that succeeded, we know we'll be keeping all the
1260 if (h
->dynindx
!= -1)
1264 h
->dyn_relocs
= NULL
;
1269 /* Finally, allocate space. */
1270 for (p
= h
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1272 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
1273 sreloc
->size
+= p
->count
* sizeof (ElfNN_External_Rela
);
1279 /* Allocate space in .plt, .got and associated reloc sections for
1280 ifunc dynamic relocs. */
1283 allocate_ifunc_dynrelocs (struct elf_link_hash_entry
*h
,
1286 struct bfd_link_info
*info
;
1288 if (h
->root
.type
== bfd_link_hash_indirect
)
1291 if (h
->root
.type
== bfd_link_hash_warning
)
1292 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1294 info
= (struct bfd_link_info
*) inf
;
1296 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
1297 here if it is defined and referenced in a non-shared object. */
1298 if (h
->type
== STT_GNU_IFUNC
1300 return _bfd_elf_allocate_ifunc_dyn_relocs (info
, h
,
1309 /* Allocate space in .plt, .got and associated reloc sections for
1310 local ifunc dynamic relocs. */
1313 allocate_local_ifunc_dynrelocs (void **slot
, void *inf
)
1315 struct elf_link_hash_entry
*h
1316 = (struct elf_link_hash_entry
*) *slot
;
1318 if (h
->type
!= STT_GNU_IFUNC
1322 || h
->root
.type
!= bfd_link_hash_defined
)
1325 return allocate_ifunc_dynrelocs (h
, inf
);
1329 riscv_elf_size_dynamic_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
1331 struct riscv_elf_link_hash_table
*htab
;
1336 htab
= riscv_elf_hash_table (info
);
1337 BFD_ASSERT (htab
!= NULL
);
1338 dynobj
= htab
->elf
.dynobj
;
1339 BFD_ASSERT (dynobj
!= NULL
);
1341 if (elf_hash_table (info
)->dynamic_sections_created
)
1343 /* Set the contents of the .interp section to the interpreter. */
1344 if (bfd_link_executable (info
) && !info
->nointerp
)
1346 s
= bfd_get_linker_section (dynobj
, ".interp");
1347 BFD_ASSERT (s
!= NULL
);
1348 s
->size
= strlen (ELFNN_DYNAMIC_INTERPRETER
) + 1;
1349 s
->contents
= (unsigned char *) ELFNN_DYNAMIC_INTERPRETER
;
1353 /* Set up .got offsets for local syms, and space for local dynamic
1355 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
1357 bfd_signed_vma
*local_got
;
1358 bfd_signed_vma
*end_local_got
;
1359 char *local_tls_type
;
1360 bfd_size_type locsymcount
;
1361 Elf_Internal_Shdr
*symtab_hdr
;
1364 if (! is_riscv_elf (ibfd
))
1367 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
1369 struct elf_dyn_relocs
*p
;
1371 for (p
= elf_section_data (s
)->local_dynrel
; p
!= NULL
; p
= p
->next
)
1373 if (!bfd_is_abs_section (p
->sec
)
1374 && bfd_is_abs_section (p
->sec
->output_section
))
1376 /* Input section has been discarded, either because
1377 it is a copy of a linkonce section or due to
1378 linker script /DISCARD/, so we'll be discarding
1381 else if (p
->count
!= 0)
1383 srel
= elf_section_data (p
->sec
)->sreloc
;
1384 srel
->size
+= p
->count
* sizeof (ElfNN_External_Rela
);
1385 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
1386 info
->flags
|= DF_TEXTREL
;
1391 local_got
= elf_local_got_refcounts (ibfd
);
1395 symtab_hdr
= &elf_symtab_hdr (ibfd
);
1396 locsymcount
= symtab_hdr
->sh_info
;
1397 end_local_got
= local_got
+ locsymcount
;
1398 local_tls_type
= _bfd_riscv_elf_local_got_tls_type (ibfd
);
1400 srel
= htab
->elf
.srelgot
;
1401 for (; local_got
< end_local_got
; ++local_got
, ++local_tls_type
)
1405 *local_got
= s
->size
;
1406 s
->size
+= RISCV_ELF_WORD_BYTES
;
1407 if (*local_tls_type
& GOT_TLS_GD
)
1408 s
->size
+= RISCV_ELF_WORD_BYTES
;
1409 if (bfd_link_pic (info
)
1410 || (*local_tls_type
& (GOT_TLS_GD
| GOT_TLS_IE
)))
1411 srel
->size
+= sizeof (ElfNN_External_Rela
);
1414 *local_got
= (bfd_vma
) -1;
1418 /* Allocate .plt and .got entries and space dynamic relocs for
1420 elf_link_hash_traverse (&htab
->elf
, allocate_dynrelocs
, info
);
1422 /* Allocate .plt and .got entries and space dynamic relocs for
1423 global ifunc symbols. */
1424 elf_link_hash_traverse (&htab
->elf
, allocate_ifunc_dynrelocs
, info
);
1426 /* Allocate .plt and .got entries and space dynamic relocs for
1427 local ifunc symbols. */
1428 htab_traverse (htab
->loc_hash_table
, allocate_local_ifunc_dynrelocs
, info
);
1430 /* Used to resolve the dynamic relocs overwite problems when
1431 generating static executable. */
1432 if (htab
->elf
.irelplt
)
1433 htab
->last_iplt_index
= htab
->elf
.irelplt
->reloc_count
- 1;
1435 if (htab
->elf
.sgotplt
)
1437 struct elf_link_hash_entry
*got
;
1438 got
= elf_link_hash_lookup (elf_hash_table (info
),
1439 "_GLOBAL_OFFSET_TABLE_",
1440 FALSE
, FALSE
, FALSE
);
1442 /* Don't allocate .got.plt section if there are no GOT nor PLT
1443 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
1445 || !got
->ref_regular_nonweak
)
1446 && (htab
->elf
.sgotplt
->size
== GOTPLT_HEADER_SIZE
)
1447 && (htab
->elf
.splt
== NULL
1448 || htab
->elf
.splt
->size
== 0)
1449 && (htab
->elf
.sgot
== NULL
1450 || (htab
->elf
.sgot
->size
1451 == get_elf_backend_data (output_bfd
)->got_header_size
)))
1452 htab
->elf
.sgotplt
->size
= 0;
1455 /* The check_relocs and adjust_dynamic_symbol entry points have
1456 determined the sizes of the various dynamic sections. Allocate
1458 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1460 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1463 if (s
== htab
->elf
.splt
1464 || s
== htab
->elf
.sgot
1465 || s
== htab
->elf
.sgotplt
1466 || s
== htab
->elf
.iplt
1467 || s
== htab
->elf
.igotplt
1468 || s
== htab
->elf
.sdynbss
1469 || s
== htab
->elf
.sdynrelro
1470 || s
== htab
->sdyntdata
)
1472 /* Strip this section if we don't need it; see the
1475 else if (strncmp (s
->name
, ".rela", 5) == 0)
1479 /* We use the reloc_count field as a counter if we need
1480 to copy relocs into the output file. */
1486 /* It's not one of our sections. */
1492 /* If we don't need this section, strip it from the
1493 output file. This is mostly to handle .rela.bss and
1494 .rela.plt. We must create both sections in
1495 create_dynamic_sections, because they must be created
1496 before the linker maps input sections to output
1497 sections. The linker does that before
1498 adjust_dynamic_symbol is called, and it is that
1499 function which decides whether anything needs to go
1500 into these sections. */
1501 s
->flags
|= SEC_EXCLUDE
;
1505 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
1508 /* Allocate memory for the section contents. Zero the memory
1509 for the benefit of .rela.plt, which has 4 unused entries
1510 at the beginning, and we don't want garbage. */
1511 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
1512 if (s
->contents
== NULL
)
1516 return _bfd_elf_add_dynamic_tags (output_bfd
, info
, TRUE
);
1520 #define DTP_OFFSET 0x800
1522 /* Return the relocation value for a TLS dtp-relative reloc. */
1525 dtpoff (struct bfd_link_info
*info
, bfd_vma address
)
1527 /* If tls_sec is NULL, we should have signalled an error already. */
1528 if (elf_hash_table (info
)->tls_sec
== NULL
)
1530 return address
- elf_hash_table (info
)->tls_sec
->vma
- DTP_OFFSET
;
1533 /* Return the relocation value for a static TLS tp-relative relocation. */
1536 tpoff (struct bfd_link_info
*info
, bfd_vma address
)
1538 /* If tls_sec is NULL, we should have signalled an error already. */
1539 if (elf_hash_table (info
)->tls_sec
== NULL
)
1541 return address
- elf_hash_table (info
)->tls_sec
->vma
- TP_OFFSET
;
1544 /* Return the global pointer's value, or 0 if it is not in use. */
1547 riscv_global_pointer_value (struct bfd_link_info
*info
)
1549 struct bfd_link_hash_entry
*h
;
1551 h
= bfd_link_hash_lookup (info
->hash
, RISCV_GP_SYMBOL
, FALSE
, FALSE
, TRUE
);
1552 if (h
== NULL
|| h
->type
!= bfd_link_hash_defined
)
1555 return h
->u
.def
.value
+ sec_addr (h
->u
.def
.section
);
1558 /* Emplace a static relocation. */
1560 static bfd_reloc_status_type
1561 perform_relocation (const reloc_howto_type
*howto
,
1562 const Elf_Internal_Rela
*rel
,
1564 asection
*input_section
,
1568 if (howto
->pc_relative
)
1569 value
-= sec_addr (input_section
) + rel
->r_offset
;
1570 value
+= rel
->r_addend
;
1572 switch (ELFNN_R_TYPE (rel
->r_info
))
1575 case R_RISCV_TPREL_HI20
:
1576 case R_RISCV_PCREL_HI20
:
1577 case R_RISCV_GOT_HI20
:
1578 case R_RISCV_TLS_GOT_HI20
:
1579 case R_RISCV_TLS_GD_HI20
:
1580 if (ARCH_SIZE
> 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (value
)))
1581 return bfd_reloc_overflow
;
1582 value
= ENCODE_UTYPE_IMM (RISCV_CONST_HIGH_PART (value
));
1585 case R_RISCV_LO12_I
:
1586 case R_RISCV_GPREL_I
:
1587 case R_RISCV_TPREL_LO12_I
:
1588 case R_RISCV_TPREL_I
:
1589 case R_RISCV_PCREL_LO12_I
:
1590 value
= ENCODE_ITYPE_IMM (value
);
1593 case R_RISCV_LO12_S
:
1594 case R_RISCV_GPREL_S
:
1595 case R_RISCV_TPREL_LO12_S
:
1596 case R_RISCV_TPREL_S
:
1597 case R_RISCV_PCREL_LO12_S
:
1598 value
= ENCODE_STYPE_IMM (value
);
1602 case R_RISCV_CALL_PLT
:
1603 if (ARCH_SIZE
> 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (value
)))
1604 return bfd_reloc_overflow
;
1605 value
= ENCODE_UTYPE_IMM (RISCV_CONST_HIGH_PART (value
))
1606 | (ENCODE_ITYPE_IMM (value
) << 32);
1610 if (!VALID_UJTYPE_IMM (value
))
1611 return bfd_reloc_overflow
;
1612 value
= ENCODE_UJTYPE_IMM (value
);
1615 case R_RISCV_BRANCH
:
1616 if (!VALID_SBTYPE_IMM (value
))
1617 return bfd_reloc_overflow
;
1618 value
= ENCODE_SBTYPE_IMM (value
);
1621 case R_RISCV_RVC_BRANCH
:
1622 if (!VALID_RVC_B_IMM (value
))
1623 return bfd_reloc_overflow
;
1624 value
= ENCODE_RVC_B_IMM (value
);
1627 case R_RISCV_RVC_JUMP
:
1628 if (!VALID_RVC_J_IMM (value
))
1629 return bfd_reloc_overflow
;
1630 value
= ENCODE_RVC_J_IMM (value
);
1633 case R_RISCV_RVC_LUI
:
1634 if (RISCV_CONST_HIGH_PART (value
) == 0)
1636 /* Linker relaxation can convert an address equal to or greater than
1637 0x800 to slightly below 0x800. C.LUI does not accept zero as a
1638 valid immediate. We can fix this by converting it to a C.LI. */
1639 bfd_vma insn
= bfd_get (howto
->bitsize
, input_bfd
,
1640 contents
+ rel
->r_offset
);
1641 insn
= (insn
& ~MATCH_C_LUI
) | MATCH_C_LI
;
1642 bfd_put (howto
->bitsize
, input_bfd
, insn
, contents
+ rel
->r_offset
);
1643 value
= ENCODE_RVC_IMM (0);
1645 else if (!VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (value
)))
1646 return bfd_reloc_overflow
;
1648 value
= ENCODE_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (value
));
1666 case R_RISCV_32_PCREL
:
1667 case R_RISCV_TLS_DTPREL32
:
1668 case R_RISCV_TLS_DTPREL64
:
1671 case R_RISCV_DELETE
:
1672 return bfd_reloc_ok
;
1675 return bfd_reloc_notsupported
;
1678 bfd_vma word
= bfd_get (howto
->bitsize
, input_bfd
, contents
+ rel
->r_offset
);
1679 word
= (word
& ~howto
->dst_mask
) | (value
& howto
->dst_mask
);
1680 bfd_put (howto
->bitsize
, input_bfd
, word
, contents
+ rel
->r_offset
);
1682 return bfd_reloc_ok
;
1685 /* Remember all PC-relative high-part relocs we've encountered to help us
1686 later resolve the corresponding low-part relocs. */
1692 } riscv_pcrel_hi_reloc
;
1694 typedef struct riscv_pcrel_lo_reloc
1696 asection
* input_section
;
1697 struct bfd_link_info
* info
;
1698 reloc_howto_type
* howto
;
1699 const Elf_Internal_Rela
* reloc
;
1702 bfd_byte
* contents
;
1703 struct riscv_pcrel_lo_reloc
* next
;
1704 } riscv_pcrel_lo_reloc
;
1709 riscv_pcrel_lo_reloc
*lo_relocs
;
1710 } riscv_pcrel_relocs
;
1713 riscv_pcrel_reloc_hash (const void *entry
)
1715 const riscv_pcrel_hi_reloc
*e
= entry
;
1716 return (hashval_t
)(e
->address
>> 2);
1720 riscv_pcrel_reloc_eq (const void *entry1
, const void *entry2
)
1722 const riscv_pcrel_hi_reloc
*e1
= entry1
, *e2
= entry2
;
1723 return e1
->address
== e2
->address
;
1727 riscv_init_pcrel_relocs (riscv_pcrel_relocs
*p
)
1730 p
->lo_relocs
= NULL
;
1731 p
->hi_relocs
= htab_create (1024, riscv_pcrel_reloc_hash
,
1732 riscv_pcrel_reloc_eq
, free
);
1733 return p
->hi_relocs
!= NULL
;
1737 riscv_free_pcrel_relocs (riscv_pcrel_relocs
*p
)
1739 riscv_pcrel_lo_reloc
*cur
= p
->lo_relocs
;
1743 riscv_pcrel_lo_reloc
*next
= cur
->next
;
1748 htab_delete (p
->hi_relocs
);
1752 riscv_zero_pcrel_hi_reloc (Elf_Internal_Rela
*rel
,
1753 struct bfd_link_info
*info
,
1757 const reloc_howto_type
*howto
,
1760 /* We may need to reference low addreses in PC-relative modes even when the
1761 * PC is far away from these addresses. For example, undefweak references
1762 * need to produce the address 0 when linked. As 0 is far from the arbitrary
1763 * addresses that we can link PC-relative programs at, the linker can't
1764 * actually relocate references to those symbols. In order to allow these
1765 * programs to work we simply convert the PC-relative auipc sequences to
1766 * 0-relative lui sequences. */
1767 if (bfd_link_pic (info
))
1770 /* If it's possible to reference the symbol using auipc we do so, as that's
1771 * more in the spirit of the PC-relative relocations we're processing. */
1772 bfd_vma offset
= addr
- pc
;
1773 if (ARCH_SIZE
== 32 || VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (offset
)))
1776 /* If it's impossible to reference this with a LUI-based offset then don't
1777 * bother to convert it at all so users still see the PC-relative relocation
1778 * in the truncation message. */
1779 if (ARCH_SIZE
> 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (addr
)))
1782 rel
->r_info
= ELFNN_R_INFO(addr
, R_RISCV_HI20
);
1784 bfd_vma insn
= bfd_get(howto
->bitsize
, input_bfd
, contents
+ rel
->r_offset
);
1785 insn
= (insn
& ~MASK_AUIPC
) | MATCH_LUI
;
1786 bfd_put(howto
->bitsize
, input_bfd
, insn
, contents
+ rel
->r_offset
);
1791 riscv_record_pcrel_hi_reloc (riscv_pcrel_relocs
*p
, bfd_vma addr
,
1792 bfd_vma value
, bfd_boolean absolute
)
1794 bfd_vma offset
= absolute
? value
: value
- addr
;
1795 riscv_pcrel_hi_reloc entry
= {addr
, offset
};
1796 riscv_pcrel_hi_reloc
**slot
=
1797 (riscv_pcrel_hi_reloc
**) htab_find_slot (p
->hi_relocs
, &entry
, INSERT
);
1799 BFD_ASSERT (*slot
== NULL
);
1800 *slot
= (riscv_pcrel_hi_reloc
*) bfd_malloc (sizeof (riscv_pcrel_hi_reloc
));
1808 riscv_record_pcrel_lo_reloc (riscv_pcrel_relocs
*p
,
1809 asection
*input_section
,
1810 struct bfd_link_info
*info
,
1811 reloc_howto_type
*howto
,
1812 const Elf_Internal_Rela
*reloc
,
1817 riscv_pcrel_lo_reloc
*entry
;
1818 entry
= (riscv_pcrel_lo_reloc
*) bfd_malloc (sizeof (riscv_pcrel_lo_reloc
));
1821 *entry
= (riscv_pcrel_lo_reloc
) {input_section
, info
, howto
, reloc
, addr
,
1822 name
, contents
, p
->lo_relocs
};
1823 p
->lo_relocs
= entry
;
1828 riscv_resolve_pcrel_lo_relocs (riscv_pcrel_relocs
*p
)
1830 riscv_pcrel_lo_reloc
*r
;
1832 for (r
= p
->lo_relocs
; r
!= NULL
; r
= r
->next
)
1834 bfd
*input_bfd
= r
->input_section
->owner
;
1836 riscv_pcrel_hi_reloc search
= {r
->addr
, 0};
1837 riscv_pcrel_hi_reloc
*entry
= htab_find (p
->hi_relocs
, &search
);
1839 /* Check for overflow into bit 11 when adding reloc addend. */
1840 || (! (entry
->value
& 0x800)
1841 && ((entry
->value
+ r
->reloc
->r_addend
) & 0x800)))
1843 char *string
= (entry
== NULL
1844 ? "%pcrel_lo missing matching %pcrel_hi"
1845 : "%pcrel_lo overflow with an addend");
1846 (*r
->info
->callbacks
->reloc_dangerous
)
1847 (r
->info
, string
, input_bfd
, r
->input_section
, r
->reloc
->r_offset
);
1851 perform_relocation (r
->howto
, r
->reloc
, entry
->value
, r
->input_section
,
1852 input_bfd
, r
->contents
);
1858 /* Relocate a RISC-V ELF section.
1860 The RELOCATE_SECTION function is called by the new ELF backend linker
1861 to handle the relocations for a section.
1863 The relocs are always passed as Rela structures.
1865 This function is responsible for adjusting the section contents as
1866 necessary, and (if generating a relocatable output file) adjusting
1867 the reloc addend as necessary.
1869 This function does not have to worry about setting the reloc
1870 address or the reloc symbol index.
1872 LOCAL_SYMS is a pointer to the swapped in local symbols.
1874 LOCAL_SECTIONS is an array giving the section in the input file
1875 corresponding to the st_shndx field of each local symbol.
1877 The global hash table entry for the global symbols can be found
1878 via elf_sym_hashes (input_bfd).
1880 When generating relocatable output, this function must handle
1881 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
1882 going to be the section symbol corresponding to the output
1883 section, which means that the addend must be adjusted
1887 riscv_elf_relocate_section (bfd
*output_bfd
,
1888 struct bfd_link_info
*info
,
1890 asection
*input_section
,
1892 Elf_Internal_Rela
*relocs
,
1893 Elf_Internal_Sym
*local_syms
,
1894 asection
**local_sections
)
1896 Elf_Internal_Rela
*rel
;
1897 Elf_Internal_Rela
*relend
;
1898 riscv_pcrel_relocs pcrel_relocs
;
1899 bfd_boolean ret
= FALSE
;
1900 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
1901 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (input_bfd
);
1902 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (input_bfd
);
1903 bfd_vma
*local_got_offsets
= elf_local_got_offsets (input_bfd
);
1904 bfd_boolean absolute
;
1906 if (!riscv_init_pcrel_relocs (&pcrel_relocs
))
1909 relend
= relocs
+ input_section
->reloc_count
;
1910 for (rel
= relocs
; rel
< relend
; rel
++)
1912 unsigned long r_symndx
;
1913 struct elf_link_hash_entry
*h
;
1914 Elf_Internal_Sym
*sym
;
1917 bfd_reloc_status_type r
= bfd_reloc_ok
;
1918 const char *name
= NULL
;
1919 bfd_vma off
, ie_off
;
1920 bfd_boolean unresolved_reloc
, is_ie
= FALSE
;
1921 bfd_vma pc
= sec_addr (input_section
) + rel
->r_offset
;
1922 int r_type
= ELFNN_R_TYPE (rel
->r_info
), tls_type
;
1923 reloc_howto_type
*howto
= riscv_elf_rtype_to_howto (input_bfd
, r_type
);
1924 const char *msg
= NULL
;
1925 char *msg_buf
= NULL
;
1926 bfd_boolean resolved_to_zero
;
1929 || r_type
== R_RISCV_GNU_VTINHERIT
|| r_type
== R_RISCV_GNU_VTENTRY
)
1932 /* This is a final link. */
1933 r_symndx
= ELFNN_R_SYM (rel
->r_info
);
1937 unresolved_reloc
= FALSE
;
1938 if (r_symndx
< symtab_hdr
->sh_info
)
1940 sym
= local_syms
+ r_symndx
;
1941 sec
= local_sections
[r_symndx
];
1942 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
1944 /* Relocate against local STT_GNU_IFUNC symbol. */
1945 if (!bfd_link_relocatable (info
)
1946 && ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
1948 h
= riscv_elf_get_local_sym_hash (htab
, input_bfd
, rel
, FALSE
);
1952 /* Set STT_GNU_IFUNC symbol value. */
1953 h
->root
.u
.def
.value
= sym
->st_value
;
1954 h
->root
.u
.def
.section
= sec
;
1959 bfd_boolean warned
, ignored
;
1961 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
1962 r_symndx
, symtab_hdr
, sym_hashes
,
1964 unresolved_reloc
, warned
, ignored
);
1967 /* To avoid generating warning messages about truncated
1968 relocations, set the relocation's address to be the same as
1969 the start of this section. */
1970 if (input_section
->output_section
!= NULL
)
1971 relocation
= input_section
->output_section
->vma
;
1977 if (sec
!= NULL
&& discarded_section (sec
))
1978 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
1979 rel
, 1, relend
, howto
, 0, contents
);
1981 if (bfd_link_relocatable (info
))
1984 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
1985 it here if it is defined in a non-shared object. */
1987 && h
->type
== STT_GNU_IFUNC
1990 asection
*plt
, *base_got
;
1992 if ((input_section
->flags
& SEC_ALLOC
) == 0)
1994 /* If this is a SHT_NOTE section without SHF_ALLOC, treat
1995 STT_GNU_IFUNC symbol as STT_FUNC. */
1996 if (elf_section_type (input_section
) == SHT_NOTE
)
1999 /* Dynamic relocs are not propagated for SEC_DEBUGGING
2000 sections because such sections are not SEC_ALLOC and
2001 thus ld.so will not process them. */
2002 if ((input_section
->flags
& SEC_DEBUGGING
) != 0)
2007 else if (h
->plt
.offset
== (bfd_vma
) -1
2008 /* The following relocation may not need the .plt entries
2009 when all references to a STT_GNU_IFUNC symbols are done
2010 via GOT or static function pointers. */
2011 && r_type
!= R_RISCV_32
2012 && r_type
!= R_RISCV_64
2013 && r_type
!= R_RISCV_HI20
2014 && r_type
!= R_RISCV_GOT_HI20
2015 && r_type
!= R_RISCV_LO12_I
2016 && r_type
!= R_RISCV_LO12_S
)
2017 goto bad_ifunc_reloc
;
2019 /* STT_GNU_IFUNC symbol must go through PLT. */
2020 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
2021 relocation
= plt
->output_section
->vma
2022 + plt
->output_offset
2029 if (rel
->r_addend
!= 0)
2031 if (h
->root
.root
.string
)
2032 name
= h
->root
.root
.string
;
2034 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
, NULL
);
2037 /* xgettext:c-format */
2038 (_("%pB: relocation %s against STT_GNU_IFUNC "
2039 "symbol `%s' has non-zero addend: %" PRId64
),
2040 input_bfd
, howto
->name
, name
, (int64_t) rel
->r_addend
);
2041 bfd_set_error (bfd_error_bad_value
);
2045 /* Generate dynamic relocation only when there is a non-GOT
2046 reference in a shared object or there is no PLT. */
2047 if ((bfd_link_pic (info
) && h
->non_got_ref
)
2048 || h
->plt
.offset
== (bfd_vma
) -1)
2050 Elf_Internal_Rela outrel
;
2053 /* Need a dynamic relocation to get the real function
2055 outrel
.r_offset
= _bfd_elf_section_offset (output_bfd
,
2059 if (outrel
.r_offset
== (bfd_vma
) -1
2060 || outrel
.r_offset
== (bfd_vma
) -2)
2063 outrel
.r_offset
+= input_section
->output_section
->vma
2064 + input_section
->output_offset
;
2066 if (h
->dynindx
== -1
2068 || bfd_link_executable (info
))
2070 info
->callbacks
->minfo
2071 (_("Local IFUNC function `%s' in %pB\n"),
2072 h
->root
.root
.string
,
2073 h
->root
.u
.def
.section
->owner
);
2075 /* This symbol is resolved locally. */
2076 outrel
.r_info
= ELFNN_R_INFO (0, R_RISCV_IRELATIVE
);
2077 outrel
.r_addend
= h
->root
.u
.def
.value
2078 + h
->root
.u
.def
.section
->output_section
->vma
2079 + h
->root
.u
.def
.section
->output_offset
;
2083 outrel
.r_info
= ELFNN_R_INFO (h
->dynindx
, r_type
);
2084 outrel
.r_addend
= 0;
2087 /* Dynamic relocations are stored in
2088 1. .rela.ifunc section in PIC object.
2089 2. .rela.got section in dynamic executable.
2090 3. .rela.iplt section in static executable. */
2091 if (bfd_link_pic (info
))
2092 sreloc
= htab
->elf
.irelifunc
;
2093 else if (htab
->elf
.splt
!= NULL
)
2094 sreloc
= htab
->elf
.srelgot
;
2096 sreloc
= htab
->elf
.irelplt
;
2098 riscv_elf_append_rela (output_bfd
, sreloc
, &outrel
);
2100 /* If this reloc is against an external symbol, we
2101 do not want to fiddle with the addend. Otherwise,
2102 we need to include the symbol value so that it
2103 becomes an addend for the dynamic reloc. For an
2104 internal symbol, we have updated addend. */
2109 case R_RISCV_GOT_HI20
:
2110 base_got
= htab
->elf
.sgot
;
2111 off
= h
->got
.offset
;
2113 if (base_got
== NULL
)
2116 if (off
== (bfd_vma
) -1)
2120 /* We can't use h->got.offset here to save state, or
2121 even just remember the offset, as finish_dynamic_symbol
2122 would use that as offset into .got. */
2124 if (htab
->elf
.splt
!= NULL
)
2126 plt_idx
= (h
->plt
.offset
- PLT_HEADER_SIZE
)
2128 off
= GOTPLT_HEADER_SIZE
+ (plt_idx
* GOT_ENTRY_SIZE
);
2129 base_got
= htab
->elf
.sgotplt
;
2133 plt_idx
= h
->plt
.offset
/ PLT_ENTRY_SIZE
;
2134 off
= plt_idx
* GOT_ENTRY_SIZE
;
2135 base_got
= htab
->elf
.igotplt
;
2138 if (h
->dynindx
== -1
2142 /* This references the local definition. We must
2143 initialize this entry in the global offset table.
2144 Since the offset must always be a multiple of 8,
2145 we use the least significant bit to record
2146 whether we have initialized it already.
2148 When doing a dynamic link, we create a .rela.got
2149 relocation entry to initialize the value. This
2150 is done in the finish_dynamic_symbol routine. */
2155 bfd_put_NN (output_bfd
, relocation
,
2156 base_got
->contents
+ off
);
2157 /* Note that this is harmless for the case,
2158 as -1 | 1 still is -1. */
2164 relocation
= base_got
->output_section
->vma
2165 + base_got
->output_offset
+ off
;
2167 r_type
= ELFNN_R_TYPE (rel
->r_info
);
2168 howto
= riscv_elf_rtype_to_howto (input_bfd
, r_type
);
2170 r
= bfd_reloc_notsupported
;
2171 else if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs
, pc
,
2173 r
= bfd_reloc_overflow
;
2177 case R_RISCV_CALL_PLT
:
2179 case R_RISCV_LO12_I
:
2180 case R_RISCV_LO12_S
:
2183 case R_RISCV_PCREL_HI20
:
2184 r_type
= ELFNN_R_TYPE (rel
->r_info
);
2185 howto
= riscv_elf_rtype_to_howto (input_bfd
, r_type
);
2187 r
= bfd_reloc_notsupported
;
2188 else if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs
, pc
,
2190 r
= bfd_reloc_overflow
;
2195 if (h
->root
.root
.string
)
2196 name
= h
->root
.root
.string
;
2198 /* The entry of local ifunc is fake in global hash table,
2199 we should find the name by the original local symbol. */
2200 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
, NULL
);
2203 /* xgettext:c-format */
2204 (_("%pB: relocation %s against STT_GNU_IFUNC "
2205 "symbol `%s' isn't supported"), input_bfd
,
2207 bfd_set_error (bfd_error_bad_value
);
2214 name
= h
->root
.root
.string
;
2217 name
= (bfd_elf_string_from_elf_section
2218 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
2219 if (name
== NULL
|| *name
== '\0')
2220 name
= bfd_section_name (sec
);
2223 resolved_to_zero
= (h
!= NULL
2224 && UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
));
2230 case R_RISCV_TPREL_ADD
:
2232 case R_RISCV_JUMP_SLOT
:
2233 case R_RISCV_RELATIVE
:
2234 /* These require nothing of us at all. */
2238 case R_RISCV_BRANCH
:
2239 case R_RISCV_RVC_BRANCH
:
2240 case R_RISCV_RVC_LUI
:
2241 case R_RISCV_LO12_I
:
2242 case R_RISCV_LO12_S
:
2247 case R_RISCV_32_PCREL
:
2248 case R_RISCV_DELETE
:
2249 /* These require no special handling beyond perform_relocation. */
2252 case R_RISCV_GOT_HI20
:
2255 bfd_boolean dyn
, pic
;
2257 off
= h
->got
.offset
;
2258 BFD_ASSERT (off
!= (bfd_vma
) -1);
2259 dyn
= elf_hash_table (info
)->dynamic_sections_created
;
2260 pic
= bfd_link_pic (info
);
2262 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, pic
, h
)
2263 || (pic
&& SYMBOL_REFERENCES_LOCAL (info
, h
)))
2265 /* This is actually a static link, or it is a
2266 -Bsymbolic link and the symbol is defined
2267 locally, or the symbol was forced to be local
2268 because of a version file. We must initialize
2269 this entry in the global offset table. Since the
2270 offset must always be a multiple of the word size,
2271 we use the least significant bit to record whether
2272 we have initialized it already.
2274 When doing a dynamic link, we create a .rela.got
2275 relocation entry to initialize the value. This
2276 is done in the finish_dynamic_symbol routine. */
2281 bfd_put_NN (output_bfd
, relocation
,
2282 htab
->elf
.sgot
->contents
+ off
);
2287 unresolved_reloc
= FALSE
;
2291 BFD_ASSERT (local_got_offsets
!= NULL
2292 && local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
2294 off
= local_got_offsets
[r_symndx
];
2296 /* The offset must always be a multiple of the word size.
2297 So, we can use the least significant bit to record
2298 whether we have already processed this entry. */
2303 if (bfd_link_pic (info
))
2306 Elf_Internal_Rela outrel
;
2308 /* We need to generate a R_RISCV_RELATIVE reloc
2309 for the dynamic linker. */
2310 s
= htab
->elf
.srelgot
;
2311 BFD_ASSERT (s
!= NULL
);
2313 outrel
.r_offset
= sec_addr (htab
->elf
.sgot
) + off
;
2315 ELFNN_R_INFO (0, R_RISCV_RELATIVE
);
2316 outrel
.r_addend
= relocation
;
2318 riscv_elf_append_rela (output_bfd
, s
, &outrel
);
2321 bfd_put_NN (output_bfd
, relocation
,
2322 htab
->elf
.sgot
->contents
+ off
);
2323 local_got_offsets
[r_symndx
] |= 1;
2326 relocation
= sec_addr (htab
->elf
.sgot
) + off
;
2327 absolute
= riscv_zero_pcrel_hi_reloc (rel
,
2334 r_type
= ELFNN_R_TYPE (rel
->r_info
);
2335 howto
= riscv_elf_rtype_to_howto (input_bfd
, r_type
);
2337 r
= bfd_reloc_notsupported
;
2338 else if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs
, pc
,
2339 relocation
, absolute
))
2340 r
= bfd_reloc_overflow
;
2348 bfd_vma old_value
= bfd_get (howto
->bitsize
, input_bfd
,
2349 contents
+ rel
->r_offset
);
2350 relocation
= old_value
+ relocation
;
2360 bfd_vma old_value
= bfd_get (howto
->bitsize
, input_bfd
,
2361 contents
+ rel
->r_offset
);
2362 relocation
= old_value
- relocation
;
2367 case R_RISCV_CALL_PLT
:
2368 /* Handle a call to an undefined weak function. This won't be
2369 relaxed, so we have to handle it here. */
2370 if (h
!= NULL
&& h
->root
.type
== bfd_link_hash_undefweak
2371 && (!bfd_link_pic (info
) || h
->plt
.offset
== MINUS_ONE
))
2373 /* We can use x0 as the base register. */
2374 bfd_vma insn
= bfd_get_32 (input_bfd
,
2375 contents
+ rel
->r_offset
+ 4);
2376 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
2377 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
+ 4);
2378 /* Set the relocation value so that we get 0 after the pc
2379 relative adjustment. */
2380 relocation
= sec_addr (input_section
) + rel
->r_offset
;
2385 case R_RISCV_RVC_JUMP
:
2386 /* This line has to match the check in _bfd_riscv_relax_section. */
2387 if (bfd_link_pic (info
) && h
!= NULL
&& h
->plt
.offset
!= MINUS_ONE
)
2389 /* Refer to the PLT entry. */
2390 relocation
= sec_addr (htab
->elf
.splt
) + h
->plt
.offset
;
2391 unresolved_reloc
= FALSE
;
2395 case R_RISCV_TPREL_HI20
:
2396 relocation
= tpoff (info
, relocation
);
2399 case R_RISCV_TPREL_LO12_I
:
2400 case R_RISCV_TPREL_LO12_S
:
2401 relocation
= tpoff (info
, relocation
);
2404 case R_RISCV_TPREL_I
:
2405 case R_RISCV_TPREL_S
:
2406 relocation
= tpoff (info
, relocation
);
2407 if (VALID_ITYPE_IMM (relocation
+ rel
->r_addend
))
2409 /* We can use tp as the base register. */
2410 bfd_vma insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2411 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
2412 insn
|= X_TP
<< OP_SH_RS1
;
2413 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
2416 r
= bfd_reloc_overflow
;
2419 case R_RISCV_GPREL_I
:
2420 case R_RISCV_GPREL_S
:
2422 bfd_vma gp
= riscv_global_pointer_value (info
);
2423 bfd_boolean x0_base
= VALID_ITYPE_IMM (relocation
+ rel
->r_addend
);
2424 if (x0_base
|| VALID_ITYPE_IMM (relocation
+ rel
->r_addend
- gp
))
2426 /* We can use x0 or gp as the base register. */
2427 bfd_vma insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2428 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
2431 rel
->r_addend
-= gp
;
2432 insn
|= X_GP
<< OP_SH_RS1
;
2434 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
2437 r
= bfd_reloc_overflow
;
2441 case R_RISCV_PCREL_HI20
:
2442 absolute
= riscv_zero_pcrel_hi_reloc (rel
,
2449 r_type
= ELFNN_R_TYPE (rel
->r_info
);
2450 howto
= riscv_elf_rtype_to_howto (input_bfd
, r_type
);
2452 r
= bfd_reloc_notsupported
;
2453 else if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs
, pc
,
2454 relocation
+ rel
->r_addend
,
2456 r
= bfd_reloc_overflow
;
2459 case R_RISCV_PCREL_LO12_I
:
2460 case R_RISCV_PCREL_LO12_S
:
2461 /* We don't allow section symbols plus addends as the auipc address,
2462 because then riscv_relax_delete_bytes would have to search through
2463 all relocs to update these addends. This is also ambiguous, as
2464 we do allow offsets to be added to the target address, which are
2465 not to be used to find the auipc address. */
2466 if (((sym
!= NULL
&& (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
))
2467 || (h
!= NULL
&& h
->type
== STT_SECTION
))
2470 msg
= _("%pcrel_lo section symbol with an addend");
2471 r
= bfd_reloc_dangerous
;
2475 if (riscv_record_pcrel_lo_reloc (&pcrel_relocs
, input_section
, info
,
2476 howto
, rel
, relocation
, name
,
2479 r
= bfd_reloc_overflow
;
2482 case R_RISCV_TLS_DTPREL32
:
2483 case R_RISCV_TLS_DTPREL64
:
2484 relocation
= dtpoff (info
, relocation
);
2489 if ((input_section
->flags
& SEC_ALLOC
) == 0)
2492 if ((bfd_link_pic (info
)
2494 || (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2495 && !resolved_to_zero
)
2496 || h
->root
.type
!= bfd_link_hash_undefweak
)
2497 && (! howto
->pc_relative
2498 || !SYMBOL_CALLS_LOCAL (info
, h
)))
2499 || (!bfd_link_pic (info
)
2505 || h
->root
.type
== bfd_link_hash_undefweak
2506 || h
->root
.type
== bfd_link_hash_undefined
)))
2508 Elf_Internal_Rela outrel
;
2510 bfd_boolean skip_static_relocation
, skip_dynamic_relocation
;
2512 /* When generating a shared object, these relocations
2513 are copied into the output file to be resolved at run
2517 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
2519 skip_static_relocation
= outrel
.r_offset
!= (bfd_vma
) -2;
2520 skip_dynamic_relocation
= outrel
.r_offset
>= (bfd_vma
) -2;
2521 outrel
.r_offset
+= sec_addr (input_section
);
2523 if (skip_dynamic_relocation
)
2524 memset (&outrel
, 0, sizeof outrel
);
2525 else if (h
!= NULL
&& h
->dynindx
!= -1
2526 && !(bfd_link_pic (info
)
2527 && SYMBOLIC_BIND (info
, h
)
2530 outrel
.r_info
= ELFNN_R_INFO (h
->dynindx
, r_type
);
2531 outrel
.r_addend
= rel
->r_addend
;
2535 outrel
.r_info
= ELFNN_R_INFO (0, R_RISCV_RELATIVE
);
2536 outrel
.r_addend
= relocation
+ rel
->r_addend
;
2539 sreloc
= elf_section_data (input_section
)->sreloc
;
2540 riscv_elf_append_rela (output_bfd
, sreloc
, &outrel
);
2541 if (skip_static_relocation
)
2546 case R_RISCV_TLS_GOT_HI20
:
2550 case R_RISCV_TLS_GD_HI20
:
2553 off
= h
->got
.offset
;
2558 off
= local_got_offsets
[r_symndx
];
2559 local_got_offsets
[r_symndx
] |= 1;
2562 tls_type
= _bfd_riscv_elf_tls_type (input_bfd
, h
, r_symndx
);
2563 BFD_ASSERT (tls_type
& (GOT_TLS_IE
| GOT_TLS_GD
));
2564 /* If this symbol is referenced by both GD and IE TLS, the IE
2565 reference's GOT slot follows the GD reference's slots. */
2567 if ((tls_type
& GOT_TLS_GD
) && (tls_type
& GOT_TLS_IE
))
2568 ie_off
= 2 * GOT_ENTRY_SIZE
;
2574 Elf_Internal_Rela outrel
;
2576 bfd_boolean need_relocs
= FALSE
;
2578 if (htab
->elf
.srelgot
== NULL
)
2583 bfd_boolean dyn
, pic
;
2584 dyn
= htab
->elf
.dynamic_sections_created
;
2585 pic
= bfd_link_pic (info
);
2587 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, pic
, h
)
2588 && (!pic
|| !SYMBOL_REFERENCES_LOCAL (info
, h
)))
2592 /* The GOT entries have not been initialized yet. Do it
2593 now, and emit any relocations. */
2594 if ((bfd_link_pic (info
) || indx
!= 0)
2596 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2597 || h
->root
.type
!= bfd_link_hash_undefweak
))
2600 if (tls_type
& GOT_TLS_GD
)
2604 outrel
.r_offset
= sec_addr (htab
->elf
.sgot
) + off
;
2605 outrel
.r_addend
= 0;
2606 outrel
.r_info
= ELFNN_R_INFO (indx
, R_RISCV_TLS_DTPMODNN
);
2607 bfd_put_NN (output_bfd
, 0,
2608 htab
->elf
.sgot
->contents
+ off
);
2609 riscv_elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &outrel
);
2612 BFD_ASSERT (! unresolved_reloc
);
2613 bfd_put_NN (output_bfd
,
2614 dtpoff (info
, relocation
),
2615 (htab
->elf
.sgot
->contents
+ off
+
2616 RISCV_ELF_WORD_BYTES
));
2620 bfd_put_NN (output_bfd
, 0,
2621 (htab
->elf
.sgot
->contents
+ off
+
2622 RISCV_ELF_WORD_BYTES
));
2623 outrel
.r_info
= ELFNN_R_INFO (indx
, R_RISCV_TLS_DTPRELNN
);
2624 outrel
.r_offset
+= RISCV_ELF_WORD_BYTES
;
2625 riscv_elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &outrel
);
2630 /* If we are not emitting relocations for a
2631 general dynamic reference, then we must be in a
2632 static link or an executable link with the
2633 symbol binding locally. Mark it as belonging
2634 to module 1, the executable. */
2635 bfd_put_NN (output_bfd
, 1,
2636 htab
->elf
.sgot
->contents
+ off
);
2637 bfd_put_NN (output_bfd
,
2638 dtpoff (info
, relocation
),
2639 (htab
->elf
.sgot
->contents
+ off
+
2640 RISCV_ELF_WORD_BYTES
));
2644 if (tls_type
& GOT_TLS_IE
)
2648 bfd_put_NN (output_bfd
, 0,
2649 htab
->elf
.sgot
->contents
+ off
+ ie_off
);
2650 outrel
.r_offset
= sec_addr (htab
->elf
.sgot
)
2652 outrel
.r_addend
= 0;
2654 outrel
.r_addend
= tpoff (info
, relocation
);
2655 outrel
.r_info
= ELFNN_R_INFO (indx
, R_RISCV_TLS_TPRELNN
);
2656 riscv_elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &outrel
);
2660 bfd_put_NN (output_bfd
, tpoff (info
, relocation
),
2661 htab
->elf
.sgot
->contents
+ off
+ ie_off
);
2666 BFD_ASSERT (off
< (bfd_vma
) -2);
2667 relocation
= sec_addr (htab
->elf
.sgot
) + off
+ (is_ie
? ie_off
: 0);
2668 if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs
, pc
,
2670 r
= bfd_reloc_overflow
;
2671 unresolved_reloc
= FALSE
;
2675 r
= bfd_reloc_notsupported
;
2678 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2679 because such sections are not SEC_ALLOC and thus ld.so will
2680 not process them. */
2681 if (unresolved_reloc
2682 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
2684 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
2685 rel
->r_offset
) != (bfd_vma
) -1)
2690 case R_RISCV_RVC_JUMP
:
2691 if (asprintf (&msg_buf
,
2692 _("%%X%%P: relocation %s against `%s' can "
2693 "not be used when making a shared object; "
2694 "recompile with -fPIC\n"),
2696 h
->root
.root
.string
) == -1)
2701 if (asprintf (&msg_buf
,
2702 _("%%X%%P: unresolvable %s relocation against "
2705 h
->root
.root
.string
) == -1)
2711 r
= bfd_reloc_notsupported
;
2715 if (r
== bfd_reloc_ok
)
2716 r
= perform_relocation (howto
, rel
, relocation
, input_section
,
2717 input_bfd
, contents
);
2719 /* We should have already detected the error and set message before.
2720 If the error message isn't set since the linker runs out of memory
2721 or we don't set it before, then we should set the default message
2722 with the "internal error" string here. */
2728 case bfd_reloc_overflow
:
2729 info
->callbacks
->reloc_overflow
2730 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
2731 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
2734 case bfd_reloc_undefined
:
2735 info
->callbacks
->undefined_symbol
2736 (info
, name
, input_bfd
, input_section
, rel
->r_offset
,
2740 case bfd_reloc_outofrange
:
2742 msg
= _("%X%P: internal error: out of range error\n");
2745 case bfd_reloc_notsupported
:
2747 msg
= _("%X%P: internal error: unsupported relocation error\n");
2750 case bfd_reloc_dangerous
:
2751 /* The error message should already be set. */
2753 msg
= _("dangerous relocation error");
2754 info
->callbacks
->reloc_dangerous
2755 (info
, msg
, input_bfd
, input_section
, rel
->r_offset
);
2759 msg
= _("%X%P: internal error: unknown error\n");
2763 /* Do not report error message for the dangerous relocation again. */
2764 if (msg
&& r
!= bfd_reloc_dangerous
)
2765 info
->callbacks
->einfo (msg
);
2767 /* Free the unused `msg_buf`. */
2770 /* We already reported the error via a callback, so don't try to report
2771 it again by returning false. That leads to spurious errors. */
2776 ret
= riscv_resolve_pcrel_lo_relocs (&pcrel_relocs
);
2778 riscv_free_pcrel_relocs (&pcrel_relocs
);
2782 /* Finish up dynamic symbol handling. We set the contents of various
2783 dynamic sections here. */
2786 riscv_elf_finish_dynamic_symbol (bfd
*output_bfd
,
2787 struct bfd_link_info
*info
,
2788 struct elf_link_hash_entry
*h
,
2789 Elf_Internal_Sym
*sym
)
2791 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
2792 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
2794 if (h
->plt
.offset
!= (bfd_vma
) -1)
2796 /* We've decided to create a PLT entry for this symbol. */
2798 bfd_vma i
, header_address
, plt_idx
, got_offset
, got_address
;
2799 uint32_t plt_entry
[PLT_ENTRY_INSNS
];
2800 Elf_Internal_Rela rela
;
2801 asection
*plt
, *gotplt
, *relplt
;
2803 /* When building a static executable, use .iplt, .igot.plt and
2804 .rela.iplt sections for STT_GNU_IFUNC symbols. */
2805 if (htab
->elf
.splt
!= NULL
)
2807 plt
= htab
->elf
.splt
;
2808 gotplt
= htab
->elf
.sgotplt
;
2809 relplt
= htab
->elf
.srelplt
;
2813 plt
= htab
->elf
.iplt
;
2814 gotplt
= htab
->elf
.igotplt
;
2815 relplt
= htab
->elf
.irelplt
;
2818 /* This symbol has an entry in the procedure linkage table. Set
2820 if ((h
->dynindx
== -1
2821 && !((h
->forced_local
|| bfd_link_executable (info
))
2823 && h
->type
== STT_GNU_IFUNC
))
2829 /* Calculate the address of the PLT header. */
2830 header_address
= sec_addr (plt
);
2832 /* Calculate the index of the entry and the offset of .got.plt entry.
2833 For static executables, we don't reserve anything. */
2834 if (plt
== htab
->elf
.splt
)
2836 plt_idx
= (h
->plt
.offset
- PLT_HEADER_SIZE
) / PLT_ENTRY_SIZE
;
2837 got_offset
= GOTPLT_HEADER_SIZE
+ (plt_idx
* GOT_ENTRY_SIZE
);
2841 plt_idx
= h
->plt
.offset
/ PLT_ENTRY_SIZE
;
2842 got_offset
= plt_idx
* GOT_ENTRY_SIZE
;
2845 /* Calculate the address of the .got.plt entry. */
2846 got_address
= sec_addr (gotplt
) + got_offset
;
2848 /* Find out where the .plt entry should go. */
2849 loc
= plt
->contents
+ h
->plt
.offset
;
2851 /* Fill in the PLT entry itself. */
2852 if (! riscv_make_plt_entry (output_bfd
, got_address
,
2853 header_address
+ h
->plt
.offset
,
2857 for (i
= 0; i
< PLT_ENTRY_INSNS
; i
++)
2858 bfd_put_32 (output_bfd
, plt_entry
[i
], loc
+ 4*i
);
2860 /* Fill in the initial value of the .got.plt entry. */
2861 loc
= gotplt
->contents
+ (got_address
- sec_addr (gotplt
));
2862 bfd_put_NN (output_bfd
, sec_addr (plt
), loc
);
2864 rela
.r_offset
= got_address
;
2866 if (h
->dynindx
== -1
2867 || ((bfd_link_executable (info
)
2868 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
2870 && h
->type
== STT_GNU_IFUNC
))
2872 info
->callbacks
->minfo (_("Local IFUNC function `%s' in %pB\n"),
2873 h
->root
.root
.string
,
2874 h
->root
.u
.def
.section
->owner
);
2876 /* If an STT_GNU_IFUNC symbol is locally defined, generate
2877 R_RISCV_IRELATIVE instead of R_RISCV_JUMP_SLOT. */
2878 asection
*sec
= h
->root
.u
.def
.section
;
2879 rela
.r_info
= ELFNN_R_INFO (0, R_RISCV_IRELATIVE
);
2880 rela
.r_addend
= h
->root
.u
.def
.value
2881 + sec
->output_section
->vma
2882 + sec
->output_offset
;
2886 /* Fill in the entry in the .rela.plt section. */
2887 rela
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_RISCV_JUMP_SLOT
);
2891 loc
= relplt
->contents
+ plt_idx
* sizeof (ElfNN_External_Rela
);
2892 bed
->s
->swap_reloca_out (output_bfd
, &rela
, loc
);
2894 if (!h
->def_regular
)
2896 /* Mark the symbol as undefined, rather than as defined in
2897 the .plt section. Leave the value alone. */
2898 sym
->st_shndx
= SHN_UNDEF
;
2899 /* If the symbol is weak, we do need to clear the value.
2900 Otherwise, the PLT entry would provide a definition for
2901 the symbol even if the symbol wasn't defined anywhere,
2902 and so the symbol would never be NULL. */
2903 if (!h
->ref_regular_nonweak
)
2908 if (h
->got
.offset
!= (bfd_vma
) -1
2909 && !(riscv_elf_hash_entry (h
)->tls_type
& (GOT_TLS_GD
| GOT_TLS_IE
))
2910 && !UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
2914 Elf_Internal_Rela rela
;
2915 bfd_boolean use_elf_append_rela
= TRUE
;
2917 /* This symbol has an entry in the GOT. Set it up. */
2919 sgot
= htab
->elf
.sgot
;
2920 srela
= htab
->elf
.srelgot
;
2921 BFD_ASSERT (sgot
!= NULL
&& srela
!= NULL
);
2923 rela
.r_offset
= sec_addr (sgot
) + (h
->got
.offset
&~ (bfd_vma
) 1);
2925 /* Handle the ifunc symbol in GOT entry. */
2927 && h
->type
== STT_GNU_IFUNC
)
2929 if (h
->plt
.offset
== (bfd_vma
) -1)
2931 /* STT_GNU_IFUNC is referenced without PLT. */
2933 if (htab
->elf
.splt
== NULL
)
2935 /* Use .rela.iplt section to store .got relocations
2936 in static executable. */
2937 srela
= htab
->elf
.irelplt
;
2939 /* Do not use riscv_elf_append_rela to add dynamic
2941 use_elf_append_rela
= FALSE
;
2944 if (SYMBOL_REFERENCES_LOCAL (info
, h
))
2946 info
->callbacks
->minfo (_("Local IFUNC function `%s' in %pB\n"),
2947 h
->root
.root
.string
,
2948 h
->root
.u
.def
.section
->owner
);
2950 rela
.r_info
= ELFNN_R_INFO (0, R_RISCV_IRELATIVE
);
2951 rela
.r_addend
= (h
->root
.u
.def
.value
2952 + h
->root
.u
.def
.section
->output_section
->vma
2953 + h
->root
.u
.def
.section
->output_offset
);
2957 /* Generate R_RISCV_NN. */
2958 BFD_ASSERT((h
->got
.offset
& 1) == 0);
2959 BFD_ASSERT (h
->dynindx
!= -1);
2960 rela
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_RISCV_NN
);
2964 else if (bfd_link_pic (info
))
2966 /* Generate R_RISCV_NN. */
2967 BFD_ASSERT((h
->got
.offset
& 1) == 0);
2968 BFD_ASSERT (h
->dynindx
!= -1);
2969 rela
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_RISCV_NN
);
2976 if (!h
->pointer_equality_needed
)
2979 /* For non-shared object, we can't use .got.plt, which
2980 contains the real function address if we need pointer
2981 equality. We load the GOT entry with the PLT entry. */
2982 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
2983 bfd_put_NN (output_bfd
, (plt
->output_section
->vma
2984 + plt
->output_offset
2986 htab
->elf
.sgot
->contents
2987 + (h
->got
.offset
& ~(bfd_vma
) 1));
2991 else if (bfd_link_pic (info
)
2992 && SYMBOL_REFERENCES_LOCAL (info
, h
))
2994 /* If this is a local symbol reference, we just want to emit
2995 a RELATIVE reloc. This can happen if it is a -Bsymbolic link,
2996 or a pie link, or the symbol was forced to be local because
2997 of a version file. The entry in the global offset table will
2998 already have been initialized in the relocate_section function. */
2999 BFD_ASSERT((h
->got
.offset
& 1) != 0);
3000 asection
*sec
= h
->root
.u
.def
.section
;
3001 rela
.r_info
= ELFNN_R_INFO (0, R_RISCV_RELATIVE
);
3002 rela
.r_addend
= (h
->root
.u
.def
.value
3003 + sec
->output_section
->vma
3004 + sec
->output_offset
);
3008 BFD_ASSERT((h
->got
.offset
& 1) == 0);
3009 BFD_ASSERT (h
->dynindx
!= -1);
3010 rela
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_RISCV_NN
);
3014 bfd_put_NN (output_bfd
, 0,
3015 sgot
->contents
+ (h
->got
.offset
& ~(bfd_vma
) 1));
3017 if (use_elf_append_rela
)
3018 riscv_elf_append_rela (output_bfd
, srela
, &rela
);
3021 /* Use riscv_elf_append_rela to add the dynamic relocs into
3022 .rela.iplt may cause the overwrite problems. Since we insert
3023 the relocs for PLT didn't handle the reloc_index of .rela.iplt,
3024 but the riscv_elf_append_rela adds the relocs to the place
3025 that are calculated from the reloc_index (in seqential).
3027 One solution is that add these dynamic relocs (GOT IFUNC)
3028 from the last of .rela.iplt section. */
3029 bfd_vma iplt_idx
= htab
->last_iplt_index
--;
3030 bfd_byte
*loc
= srela
->contents
3031 + iplt_idx
* sizeof (ElfNN_External_Rela
);
3032 bed
->s
->swap_reloca_out (output_bfd
, &rela
, loc
);
3038 Elf_Internal_Rela rela
;
3041 /* This symbols needs a copy reloc. Set it up. */
3042 BFD_ASSERT (h
->dynindx
!= -1);
3044 rela
.r_offset
= sec_addr (h
->root
.u
.def
.section
) + h
->root
.u
.def
.value
;
3045 rela
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_RISCV_COPY
);
3047 if (h
->root
.u
.def
.section
== htab
->elf
.sdynrelro
)
3048 s
= htab
->elf
.sreldynrelro
;
3050 s
= htab
->elf
.srelbss
;
3051 riscv_elf_append_rela (output_bfd
, s
, &rela
);
3054 /* Mark some specially defined symbols as absolute. */
3055 if (h
== htab
->elf
.hdynamic
3056 || (h
== htab
->elf
.hgot
|| h
== htab
->elf
.hplt
))
3057 sym
->st_shndx
= SHN_ABS
;
3062 /* Finish up local dynamic symbol handling. We set the contents of
3063 various dynamic sections here. */
3066 riscv_elf_finish_local_dynamic_symbol (void **slot
, void *inf
)
3068 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*) *slot
;
3069 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
3071 return riscv_elf_finish_dynamic_symbol (info
->output_bfd
, info
, h
, NULL
);
3074 /* Finish up the dynamic sections. */
3077 riscv_finish_dyn (bfd
*output_bfd
, struct bfd_link_info
*info
,
3078 bfd
*dynobj
, asection
*sdyn
)
3080 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
3081 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
3082 size_t dynsize
= bed
->s
->sizeof_dyn
;
3083 bfd_byte
*dyncon
, *dynconend
;
3085 dynconend
= sdyn
->contents
+ sdyn
->size
;
3086 for (dyncon
= sdyn
->contents
; dyncon
< dynconend
; dyncon
+= dynsize
)
3088 Elf_Internal_Dyn dyn
;
3091 bed
->s
->swap_dyn_in (dynobj
, dyncon
, &dyn
);
3096 s
= htab
->elf
.sgotplt
;
3097 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
3100 s
= htab
->elf
.srelplt
;
3101 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
3104 s
= htab
->elf
.srelplt
;
3105 dyn
.d_un
.d_val
= s
->size
;
3111 bed
->s
->swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3117 riscv_elf_finish_dynamic_sections (bfd
*output_bfd
,
3118 struct bfd_link_info
*info
)
3122 struct riscv_elf_link_hash_table
*htab
;
3124 htab
= riscv_elf_hash_table (info
);
3125 BFD_ASSERT (htab
!= NULL
);
3126 dynobj
= htab
->elf
.dynobj
;
3128 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
3130 if (elf_hash_table (info
)->dynamic_sections_created
)
3135 splt
= htab
->elf
.splt
;
3136 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
3138 ret
= riscv_finish_dyn (output_bfd
, info
, dynobj
, sdyn
);
3143 /* Fill in the head and tail entries in the procedure linkage table. */
3147 uint32_t plt_header
[PLT_HEADER_INSNS
];
3148 ret
= riscv_make_plt_header (output_bfd
,
3149 sec_addr (htab
->elf
.sgotplt
),
3150 sec_addr (splt
), plt_header
);
3154 for (i
= 0; i
< PLT_HEADER_INSNS
; i
++)
3155 bfd_put_32 (output_bfd
, plt_header
[i
], splt
->contents
+ 4*i
);
3157 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
3162 if (htab
->elf
.sgotplt
)
3164 asection
*output_section
= htab
->elf
.sgotplt
->output_section
;
3166 if (bfd_is_abs_section (output_section
))
3168 (*_bfd_error_handler
)
3169 (_("discarded output section: `%pA'"), htab
->elf
.sgotplt
);
3173 if (htab
->elf
.sgotplt
->size
> 0)
3175 /* Write the first two entries in .got.plt, needed for the dynamic
3177 bfd_put_NN (output_bfd
, (bfd_vma
) -1, htab
->elf
.sgotplt
->contents
);
3178 bfd_put_NN (output_bfd
, (bfd_vma
) 0,
3179 htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
);
3182 elf_section_data (output_section
)->this_hdr
.sh_entsize
= GOT_ENTRY_SIZE
;
3187 asection
*output_section
= htab
->elf
.sgot
->output_section
;
3189 if (htab
->elf
.sgot
->size
> 0)
3191 /* Set the first entry in the global offset table to the address of
3192 the dynamic section. */
3193 bfd_vma val
= sdyn
? sec_addr (sdyn
) : 0;
3194 bfd_put_NN (output_bfd
, val
, htab
->elf
.sgot
->contents
);
3197 elf_section_data (output_section
)->this_hdr
.sh_entsize
= GOT_ENTRY_SIZE
;
3200 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
3201 htab_traverse (htab
->loc_hash_table
,
3202 riscv_elf_finish_local_dynamic_symbol
,
3208 /* Return address for Ith PLT stub in section PLT, for relocation REL
3209 or (bfd_vma) -1 if it should not be included. */
3212 riscv_elf_plt_sym_val (bfd_vma i
, const asection
*plt
,
3213 const arelent
*rel ATTRIBUTE_UNUSED
)
3215 return plt
->vma
+ PLT_HEADER_SIZE
+ i
* PLT_ENTRY_SIZE
;
3218 static enum elf_reloc_type_class
3219 riscv_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
3220 const asection
*rel_sec ATTRIBUTE_UNUSED
,
3221 const Elf_Internal_Rela
*rela
)
3223 switch (ELFNN_R_TYPE (rela
->r_info
))
3225 case R_RISCV_RELATIVE
:
3226 return reloc_class_relative
;
3227 case R_RISCV_JUMP_SLOT
:
3228 return reloc_class_plt
;
3230 return reloc_class_copy
;
3232 return reloc_class_normal
;
3236 /* Given the ELF header flags in FLAGS, it returns a string that describes the
3240 riscv_float_abi_string (flagword flags
)
3242 switch (flags
& EF_RISCV_FLOAT_ABI
)
3244 case EF_RISCV_FLOAT_ABI_SOFT
:
3245 return "soft-float";
3247 case EF_RISCV_FLOAT_ABI_SINGLE
:
3248 return "single-float";
3250 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3251 return "double-float";
3253 case EF_RISCV_FLOAT_ABI_QUAD
:
3254 return "quad-float";
3261 /* The information of architecture attribute. */
3262 static riscv_subset_list_t in_subsets
;
3263 static riscv_subset_list_t out_subsets
;
3264 static riscv_subset_list_t merged_subsets
;
3266 /* Predicator for standard extension. */
3269 riscv_std_ext_p (const char *name
)
3271 return (strlen (name
) == 1) && (name
[0] != 'x') && (name
[0] != 's');
3274 /* Check if the versions are compatible. */
3277 riscv_version_mismatch (bfd
*ibfd
,
3278 struct riscv_subset_t
*in
,
3279 struct riscv_subset_t
*out
)
3281 if (in
== NULL
|| out
== NULL
)
3284 /* Since there are no version conflicts for now, we just report
3285 warning when the versions are mis-matched. */
3286 if (in
->major_version
!= out
->major_version
3287 || in
->minor_version
!= out
->minor_version
)
3290 (_("warning: %pB: mis-matched ISA version %d.%d for '%s' "
3291 "extension, the output version is %d.%d"),
3297 out
->minor_version
);
3299 /* Update the output ISA versions to the newest ones. */
3300 if ((in
->major_version
> out
->major_version
)
3301 || (in
->major_version
== out
->major_version
3302 && in
->minor_version
> out
->minor_version
))
3304 out
->major_version
= in
->major_version
;
3305 out
->minor_version
= in
->minor_version
;
3312 /* Return true if subset is 'i' or 'e'. */
3315 riscv_i_or_e_p (bfd
*ibfd
,
3317 struct riscv_subset_t
*subset
)
3319 if ((strcasecmp (subset
->name
, "e") != 0)
3320 && (strcasecmp (subset
->name
, "i") != 0))
3323 (_("error: %pB: corrupted ISA string '%s'. "
3324 "First letter should be 'i' or 'e' but got '%s'"),
3325 ibfd
, arch
, subset
->name
);
3331 /* Merge standard extensions.
3334 Return FALSE if failed to merge.
3338 `in_arch`: Raw arch string for input object.
3339 `out_arch`: Raw arch string for output object.
3340 `pin`: subset list for input object, and it'll skip all merged subset after
3342 `pout`: Like `pin`, but for output object. */
3345 riscv_merge_std_ext (bfd
*ibfd
,
3346 const char *in_arch
,
3347 const char *out_arch
,
3348 struct riscv_subset_t
**pin
,
3349 struct riscv_subset_t
**pout
)
3351 const char *standard_exts
= riscv_supported_std_ext ();
3353 struct riscv_subset_t
*in
= *pin
;
3354 struct riscv_subset_t
*out
= *pout
;
3356 /* First letter should be 'i' or 'e'. */
3357 if (!riscv_i_or_e_p (ibfd
, in_arch
, in
))
3360 if (!riscv_i_or_e_p (ibfd
, out_arch
, out
))
3363 if (strcasecmp (in
->name
, out
->name
) != 0)
3365 /* TODO: We might allow merge 'i' with 'e'. */
3367 (_("error: %pB: mis-matched ISA string to merge '%s' and '%s'"),
3368 ibfd
, in
->name
, out
->name
);
3371 else if (!riscv_version_mismatch (ibfd
, in
, out
))
3374 riscv_add_subset (&merged_subsets
,
3375 out
->name
, out
->major_version
, out
->minor_version
);
3380 /* Handle standard extension first. */
3381 for (p
= standard_exts
; *p
; ++p
)
3383 struct riscv_subset_t
*ext_in
, *ext_out
, *ext_merged
;
3384 char find_ext
[2] = {*p
, '\0'};
3385 bfd_boolean find_in
, find_out
;
3387 find_in
= riscv_lookup_subset (&in_subsets
, find_ext
, &ext_in
);
3388 find_out
= riscv_lookup_subset (&out_subsets
, find_ext
, &ext_out
);
3390 if (!find_in
&& !find_out
)
3395 && !riscv_version_mismatch (ibfd
, ext_in
, ext_out
))
3398 ext_merged
= find_out
? ext_out
: ext_in
;
3399 riscv_add_subset (&merged_subsets
, ext_merged
->name
,
3400 ext_merged
->major_version
, ext_merged
->minor_version
);
3403 /* Skip all standard extensions. */
3404 while ((in
!= NULL
) && riscv_std_ext_p (in
->name
)) in
= in
->next
;
3405 while ((out
!= NULL
) && riscv_std_ext_p (out
->name
)) out
= out
->next
;
3413 /* Merge multi letter extensions. PIN is a pointer to the head of the input
3414 object subset list. Likewise for POUT and the output object. Return TRUE
3415 on success and FALSE when a conflict is found. */
3418 riscv_merge_multi_letter_ext (bfd
*ibfd
,
3419 riscv_subset_t
**pin
,
3420 riscv_subset_t
**pout
)
3422 riscv_subset_t
*in
= *pin
;
3423 riscv_subset_t
*out
= *pout
;
3424 riscv_subset_t
*tail
;
3430 cmp
= riscv_compare_subsets (in
->name
, out
->name
);
3434 /* `in' comes before `out', append `in' and increment. */
3435 riscv_add_subset (&merged_subsets
, in
->name
, in
->major_version
,
3441 /* `out' comes before `in', append `out' and increment. */
3442 riscv_add_subset (&merged_subsets
, out
->name
, out
->major_version
,
3443 out
->minor_version
);
3448 /* Both present, check version and increment both. */
3449 if (!riscv_version_mismatch (ibfd
, in
, out
))
3452 riscv_add_subset (&merged_subsets
, out
->name
, out
->major_version
,
3453 out
->minor_version
);
3460 /* If we're here, either `in' or `out' is running longer than
3461 the other. So, we need to append the corresponding tail. */
3462 tail
= in
? in
: out
;
3466 riscv_add_subset (&merged_subsets
, tail
->name
, tail
->major_version
,
3467 tail
->minor_version
);
3475 /* Merge Tag_RISCV_arch attribute. */
3478 riscv_merge_arch_attr_info (bfd
*ibfd
, char *in_arch
, char *out_arch
)
3480 riscv_subset_t
*in
, *out
;
3481 char *merged_arch_str
;
3483 unsigned xlen_in
, xlen_out
;
3484 merged_subsets
.head
= NULL
;
3485 merged_subsets
.tail
= NULL
;
3487 riscv_parse_subset_t rpe_in
;
3488 riscv_parse_subset_t rpe_out
;
3490 /* Only assembler needs to check the default version of ISA, so just set
3491 the rpe_in.get_default_version and rpe_out.get_default_version to NULL. */
3492 rpe_in
.subset_list
= &in_subsets
;
3493 rpe_in
.error_handler
= _bfd_error_handler
;
3494 rpe_in
.xlen
= &xlen_in
;
3495 rpe_in
.get_default_version
= NULL
;
3497 rpe_out
.subset_list
= &out_subsets
;
3498 rpe_out
.error_handler
= _bfd_error_handler
;
3499 rpe_out
.xlen
= &xlen_out
;
3500 rpe_out
.get_default_version
= NULL
;
3502 if (in_arch
== NULL
&& out_arch
== NULL
)
3505 if (in_arch
== NULL
&& out_arch
!= NULL
)
3508 if (in_arch
!= NULL
&& out_arch
== NULL
)
3511 /* Parse subset from arch string. */
3512 if (!riscv_parse_subset (&rpe_in
, in_arch
))
3515 if (!riscv_parse_subset (&rpe_out
, out_arch
))
3518 /* Checking XLEN. */
3519 if (xlen_out
!= xlen_in
)
3522 (_("error: %pB: ISA string of input (%s) doesn't match "
3523 "output (%s)"), ibfd
, in_arch
, out_arch
);
3527 /* Merge subset list. */
3528 in
= in_subsets
.head
;
3529 out
= out_subsets
.head
;
3531 /* Merge standard extension. */
3532 if (!riscv_merge_std_ext (ibfd
, in_arch
, out_arch
, &in
, &out
))
3535 /* Merge all non-single letter extensions with single call. */
3536 if (!riscv_merge_multi_letter_ext (ibfd
, &in
, &out
))
3539 if (xlen_in
!= xlen_out
)
3542 (_("error: %pB: XLEN of input (%u) doesn't match "
3543 "output (%u)"), ibfd
, xlen_in
, xlen_out
);
3547 if (xlen_in
!= ARCH_SIZE
)
3550 (_("error: %pB: unsupported XLEN (%u), you might be "
3551 "using wrong emulation"), ibfd
, xlen_in
);
3555 merged_arch_str
= riscv_arch_str (ARCH_SIZE
, &merged_subsets
);
3557 /* Release the subset lists. */
3558 riscv_release_subset_list (&in_subsets
);
3559 riscv_release_subset_list (&out_subsets
);
3560 riscv_release_subset_list (&merged_subsets
);
3562 return merged_arch_str
;
3565 /* Merge object attributes from IBFD into output_bfd of INFO.
3566 Raise an error if there are conflicting attributes. */
3569 riscv_merge_attributes (bfd
*ibfd
, struct bfd_link_info
*info
)
3571 bfd
*obfd
= info
->output_bfd
;
3572 obj_attribute
*in_attr
;
3573 obj_attribute
*out_attr
;
3574 bfd_boolean result
= TRUE
;
3575 bfd_boolean priv_attrs_merged
= FALSE
;
3576 const char *sec_name
= get_elf_backend_data (ibfd
)->obj_attrs_section
;
3579 /* Skip linker created files. */
3580 if (ibfd
->flags
& BFD_LINKER_CREATED
)
3583 /* Skip any input that doesn't have an attribute section.
3584 This enables to link object files without attribute section with
3586 if (bfd_get_section_by_name (ibfd
, sec_name
) == NULL
)
3589 if (!elf_known_obj_attributes_proc (obfd
)[0].i
)
3591 /* This is the first object. Copy the attributes. */
3592 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
3594 out_attr
= elf_known_obj_attributes_proc (obfd
);
3596 /* Use the Tag_null value to indicate the attributes have been
3603 in_attr
= elf_known_obj_attributes_proc (ibfd
);
3604 out_attr
= elf_known_obj_attributes_proc (obfd
);
3606 for (i
= LEAST_KNOWN_OBJ_ATTRIBUTE
; i
< NUM_KNOWN_OBJ_ATTRIBUTES
; i
++)
3610 case Tag_RISCV_arch
:
3611 if (!out_attr
[Tag_RISCV_arch
].s
)
3612 out_attr
[Tag_RISCV_arch
].s
= in_attr
[Tag_RISCV_arch
].s
;
3613 else if (in_attr
[Tag_RISCV_arch
].s
3614 && out_attr
[Tag_RISCV_arch
].s
)
3616 /* Check arch compatible. */
3618 riscv_merge_arch_attr_info (ibfd
,
3619 in_attr
[Tag_RISCV_arch
].s
,
3620 out_attr
[Tag_RISCV_arch
].s
);
3621 if (merged_arch
== NULL
)
3624 out_attr
[Tag_RISCV_arch
].s
= "";
3627 out_attr
[Tag_RISCV_arch
].s
= merged_arch
;
3631 case Tag_RISCV_priv_spec
:
3632 case Tag_RISCV_priv_spec_minor
:
3633 case Tag_RISCV_priv_spec_revision
:
3634 /* If we have handled the priv attributes, then skip it. */
3635 if (!priv_attrs_merged
)
3637 unsigned int Tag_a
= Tag_RISCV_priv_spec
;
3638 unsigned int Tag_b
= Tag_RISCV_priv_spec_minor
;
3639 unsigned int Tag_c
= Tag_RISCV_priv_spec_revision
;
3640 enum riscv_priv_spec_class in_priv_spec
;
3641 enum riscv_priv_spec_class out_priv_spec
;
3643 /* Get the priv spec class from elf attribute numbers. */
3644 riscv_get_priv_spec_class_from_numbers (in_attr
[Tag_a
].i
,
3648 riscv_get_priv_spec_class_from_numbers (out_attr
[Tag_a
].i
,
3653 /* Allow to link the object without the priv specs. */
3654 if (out_priv_spec
== PRIV_SPEC_CLASS_NONE
)
3656 out_attr
[Tag_a
].i
= in_attr
[Tag_a
].i
;
3657 out_attr
[Tag_b
].i
= in_attr
[Tag_b
].i
;
3658 out_attr
[Tag_c
].i
= in_attr
[Tag_c
].i
;
3660 else if (in_priv_spec
!= PRIV_SPEC_CLASS_NONE
3661 && in_priv_spec
!= out_priv_spec
)
3664 (_("warning: %pB use privilege spec version %u.%u.%u but "
3665 "the output use version %u.%u.%u"),
3674 /* The priv spec v1.9.1 can not be linked with other spec
3675 versions since the conflicts. We plan to drop the
3676 v1.9.1 in a year or two, so this confict should be
3677 removed in the future. */
3678 if (in_priv_spec
== PRIV_SPEC_CLASS_1P9P1
3679 || out_priv_spec
== PRIV_SPEC_CLASS_1P9P1
)
3682 (_("warning: privilege spec version 1.9.1 can not be "
3683 "linked with other spec versions"));
3686 /* Update the output priv spec to the newest one. */
3687 if (in_priv_spec
> out_priv_spec
)
3689 out_attr
[Tag_a
].i
= in_attr
[Tag_a
].i
;
3690 out_attr
[Tag_b
].i
= in_attr
[Tag_b
].i
;
3691 out_attr
[Tag_c
].i
= in_attr
[Tag_c
].i
;
3694 priv_attrs_merged
= TRUE
;
3698 case Tag_RISCV_unaligned_access
:
3699 out_attr
[i
].i
|= in_attr
[i
].i
;
3702 case Tag_RISCV_stack_align
:
3703 if (out_attr
[i
].i
== 0)
3704 out_attr
[i
].i
= in_attr
[i
].i
;
3705 else if (in_attr
[i
].i
!= 0
3706 && out_attr
[i
].i
!= 0
3707 && out_attr
[i
].i
!= in_attr
[i
].i
)
3710 (_("error: %pB use %u-byte stack aligned but the output "
3711 "use %u-byte stack aligned"),
3712 ibfd
, in_attr
[i
].i
, out_attr
[i
].i
);
3718 result
&= _bfd_elf_merge_unknown_attribute_low (ibfd
, obfd
, i
);
3721 /* If out_attr was copied from in_attr then it won't have a type yet. */
3722 if (in_attr
[i
].type
&& !out_attr
[i
].type
)
3723 out_attr
[i
].type
= in_attr
[i
].type
;
3726 /* Merge Tag_compatibility attributes and any common GNU ones. */
3727 if (!_bfd_elf_merge_object_attributes (ibfd
, info
))
3730 /* Check for any attributes not known on RISC-V. */
3731 result
&= _bfd_elf_merge_unknown_attribute_list (ibfd
, obfd
);
3736 /* Merge backend specific data from an object file to the output
3737 object file when linking. */
3740 _bfd_riscv_elf_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
3742 bfd
*obfd
= info
->output_bfd
;
3743 flagword new_flags
, old_flags
;
3745 if (!is_riscv_elf (ibfd
) || !is_riscv_elf (obfd
))
3748 if (strcmp (bfd_get_target (ibfd
), bfd_get_target (obfd
)) != 0)
3750 (*_bfd_error_handler
)
3751 (_("%pB: ABI is incompatible with that of the selected emulation:\n"
3752 " target emulation `%s' does not match `%s'"),
3753 ibfd
, bfd_get_target (ibfd
), bfd_get_target (obfd
));
3757 if (!_bfd_elf_merge_object_attributes (ibfd
, info
))
3760 if (!riscv_merge_attributes (ibfd
, info
))
3763 new_flags
= elf_elfheader (ibfd
)->e_flags
;
3764 old_flags
= elf_elfheader (obfd
)->e_flags
;
3766 if (! elf_flags_init (obfd
))
3768 elf_flags_init (obfd
) = TRUE
;
3769 elf_elfheader (obfd
)->e_flags
= new_flags
;
3773 /* Check to see if the input BFD actually contains any sections. If not,
3774 its flags may not have been initialized either, but it cannot actually
3775 cause any incompatibility. Do not short-circuit dynamic objects; their
3776 section list may be emptied by elf_link_add_object_symbols.
3778 Also check to see if there are no code sections in the input. In this
3779 case, there is no need to check for code specific flags. */
3780 if (!(ibfd
->flags
& DYNAMIC
))
3782 bfd_boolean null_input_bfd
= TRUE
;
3783 bfd_boolean only_data_sections
= TRUE
;
3786 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
3788 if ((bfd_section_flags (sec
)
3789 & (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
3790 == (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
3791 only_data_sections
= FALSE
;
3793 null_input_bfd
= FALSE
;
3797 if (null_input_bfd
|| only_data_sections
)
3801 /* Disallow linking different float ABIs. */
3802 if ((old_flags
^ new_flags
) & EF_RISCV_FLOAT_ABI
)
3804 (*_bfd_error_handler
)
3805 (_("%pB: can't link %s modules with %s modules"), ibfd
,
3806 riscv_float_abi_string (new_flags
),
3807 riscv_float_abi_string (old_flags
));
3811 /* Disallow linking RVE and non-RVE. */
3812 if ((old_flags
^ new_flags
) & EF_RISCV_RVE
)
3814 (*_bfd_error_handler
)
3815 (_("%pB: can't link RVE with other target"), ibfd
);
3819 /* Allow linking RVC and non-RVC, and keep the RVC flag. */
3820 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_RISCV_RVC
;
3825 bfd_set_error (bfd_error_bad_value
);
3829 /* Delete some bytes from a section while relaxing. */
3832 riscv_relax_delete_bytes (bfd
*abfd
, asection
*sec
, bfd_vma addr
, size_t count
,
3833 struct bfd_link_info
*link_info
)
3835 unsigned int i
, symcount
;
3836 bfd_vma toaddr
= sec
->size
;
3837 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (abfd
);
3838 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3839 unsigned int sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
3840 struct bfd_elf_section_data
*data
= elf_section_data (sec
);
3841 bfd_byte
*contents
= data
->this_hdr
.contents
;
3843 /* Actually delete the bytes. */
3845 memmove (contents
+ addr
, contents
+ addr
+ count
, toaddr
- addr
- count
);
3847 /* Adjust the location of all of the relocs. Note that we need not
3848 adjust the addends, since all PC-relative references must be against
3849 symbols, which we will adjust below. */
3850 for (i
= 0; i
< sec
->reloc_count
; i
++)
3851 if (data
->relocs
[i
].r_offset
> addr
&& data
->relocs
[i
].r_offset
< toaddr
)
3852 data
->relocs
[i
].r_offset
-= count
;
3854 /* Adjust the local symbols defined in this section. */
3855 for (i
= 0; i
< symtab_hdr
->sh_info
; i
++)
3857 Elf_Internal_Sym
*sym
= (Elf_Internal_Sym
*) symtab_hdr
->contents
+ i
;
3858 if (sym
->st_shndx
== sec_shndx
)
3860 /* If the symbol is in the range of memory we just moved, we
3861 have to adjust its value. */
3862 if (sym
->st_value
> addr
&& sym
->st_value
<= toaddr
)
3863 sym
->st_value
-= count
;
3865 /* If the symbol *spans* the bytes we just deleted (i.e. its
3866 *end* is in the moved bytes but its *start* isn't), then we
3867 must adjust its size.
3869 This test needs to use the original value of st_value, otherwise
3870 we might accidentally decrease size when deleting bytes right
3871 before the symbol. But since deleted relocs can't span across
3872 symbols, we can't have both a st_value and a st_size decrease,
3873 so it is simpler to just use an else. */
3874 else if (sym
->st_value
<= addr
3875 && sym
->st_value
+ sym
->st_size
> addr
3876 && sym
->st_value
+ sym
->st_size
<= toaddr
)
3877 sym
->st_size
-= count
;
3881 /* Now adjust the global symbols defined in this section. */
3882 symcount
= ((symtab_hdr
->sh_size
/ sizeof (ElfNN_External_Sym
))
3883 - symtab_hdr
->sh_info
);
3885 for (i
= 0; i
< symcount
; i
++)
3887 struct elf_link_hash_entry
*sym_hash
= sym_hashes
[i
];
3889 /* The '--wrap SYMBOL' option is causing a pain when the object file,
3890 containing the definition of __wrap_SYMBOL, includes a direct
3891 call to SYMBOL as well. Since both __wrap_SYMBOL and SYMBOL reference
3892 the same symbol (which is __wrap_SYMBOL), but still exist as two
3893 different symbols in 'sym_hashes', we don't want to adjust
3894 the global symbol __wrap_SYMBOL twice. */
3895 /* The same problem occurs with symbols that are versioned_hidden, as
3896 foo becomes an alias for foo@BAR, and hence they need the same
3898 if (link_info
->wrap_hash
!= NULL
3899 || sym_hash
->versioned
== versioned_hidden
)
3901 struct elf_link_hash_entry
**cur_sym_hashes
;
3903 /* Loop only over the symbols which have already been checked. */
3904 for (cur_sym_hashes
= sym_hashes
; cur_sym_hashes
< &sym_hashes
[i
];
3907 /* If the current symbol is identical to 'sym_hash', that means
3908 the symbol was already adjusted (or at least checked). */
3909 if (*cur_sym_hashes
== sym_hash
)
3912 /* Don't adjust the symbol again. */
3913 if (cur_sym_hashes
< &sym_hashes
[i
])
3917 if ((sym_hash
->root
.type
== bfd_link_hash_defined
3918 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
3919 && sym_hash
->root
.u
.def
.section
== sec
)
3921 /* As above, adjust the value if needed. */
3922 if (sym_hash
->root
.u
.def
.value
> addr
3923 && sym_hash
->root
.u
.def
.value
<= toaddr
)
3924 sym_hash
->root
.u
.def
.value
-= count
;
3926 /* As above, adjust the size if needed. */
3927 else if (sym_hash
->root
.u
.def
.value
<= addr
3928 && sym_hash
->root
.u
.def
.value
+ sym_hash
->size
> addr
3929 && sym_hash
->root
.u
.def
.value
+ sym_hash
->size
<= toaddr
)
3930 sym_hash
->size
-= count
;
3937 /* A second format for recording PC-relative hi relocations. This stores the
3938 information required to relax them to GP-relative addresses. */
3940 typedef struct riscv_pcgp_hi_reloc riscv_pcgp_hi_reloc
;
3941 struct riscv_pcgp_hi_reloc
3948 bfd_boolean undefined_weak
;
3949 riscv_pcgp_hi_reloc
*next
;
3952 typedef struct riscv_pcgp_lo_reloc riscv_pcgp_lo_reloc
;
3953 struct riscv_pcgp_lo_reloc
3956 riscv_pcgp_lo_reloc
*next
;
3961 riscv_pcgp_hi_reloc
*hi
;
3962 riscv_pcgp_lo_reloc
*lo
;
3963 } riscv_pcgp_relocs
;
3965 /* Initialize the pcgp reloc info in P. */
3968 riscv_init_pcgp_relocs (riscv_pcgp_relocs
*p
)
3975 /* Free the pcgp reloc info in P. */
3978 riscv_free_pcgp_relocs (riscv_pcgp_relocs
*p
,
3979 bfd
*abfd ATTRIBUTE_UNUSED
,
3980 asection
*sec ATTRIBUTE_UNUSED
)
3982 riscv_pcgp_hi_reloc
*c
;
3983 riscv_pcgp_lo_reloc
*l
;
3985 for (c
= p
->hi
; c
!= NULL
;)
3987 riscv_pcgp_hi_reloc
*next
= c
->next
;
3992 for (l
= p
->lo
; l
!= NULL
;)
3994 riscv_pcgp_lo_reloc
*next
= l
->next
;
4000 /* Record pcgp hi part reloc info in P, using HI_SEC_OFF as the lookup index.
4001 The HI_ADDEND, HI_ADDR, HI_SYM, and SYM_SEC args contain info required to
4002 relax the corresponding lo part reloc. */
4005 riscv_record_pcgp_hi_reloc (riscv_pcgp_relocs
*p
, bfd_vma hi_sec_off
,
4006 bfd_vma hi_addend
, bfd_vma hi_addr
,
4007 unsigned hi_sym
, asection
*sym_sec
,
4008 bfd_boolean undefined_weak
)
4010 riscv_pcgp_hi_reloc
*new = bfd_malloc (sizeof(*new));
4013 new->hi_sec_off
= hi_sec_off
;
4014 new->hi_addend
= hi_addend
;
4015 new->hi_addr
= hi_addr
;
4016 new->hi_sym
= hi_sym
;
4017 new->sym_sec
= sym_sec
;
4018 new->undefined_weak
= undefined_weak
;
4024 /* Look up hi part pcgp reloc info in P, using HI_SEC_OFF as the lookup index.
4025 This is used by a lo part reloc to find the corresponding hi part reloc. */
4027 static riscv_pcgp_hi_reloc
*
4028 riscv_find_pcgp_hi_reloc(riscv_pcgp_relocs
*p
, bfd_vma hi_sec_off
)
4030 riscv_pcgp_hi_reloc
*c
;
4032 for (c
= p
->hi
; c
!= NULL
; c
= c
->next
)
4033 if (c
->hi_sec_off
== hi_sec_off
)
4038 /* Record pcgp lo part reloc info in P, using HI_SEC_OFF as the lookup info.
4039 This is used to record relocs that can't be relaxed. */
4042 riscv_record_pcgp_lo_reloc (riscv_pcgp_relocs
*p
, bfd_vma hi_sec_off
)
4044 riscv_pcgp_lo_reloc
*new = bfd_malloc (sizeof(*new));
4047 new->hi_sec_off
= hi_sec_off
;
4053 /* Look up lo part pcgp reloc info in P, using HI_SEC_OFF as the lookup index.
4054 This is used by a hi part reloc to find the corresponding lo part reloc. */
4057 riscv_find_pcgp_lo_reloc (riscv_pcgp_relocs
*p
, bfd_vma hi_sec_off
)
4059 riscv_pcgp_lo_reloc
*c
;
4061 for (c
= p
->lo
; c
!= NULL
; c
= c
->next
)
4062 if (c
->hi_sec_off
== hi_sec_off
)
4067 typedef bfd_boolean (*relax_func_t
) (bfd
*, asection
*, asection
*,
4068 struct bfd_link_info
*,
4069 Elf_Internal_Rela
*,
4070 bfd_vma
, bfd_vma
, bfd_vma
, bfd_boolean
*,
4071 riscv_pcgp_relocs
*,
4072 bfd_boolean undefined_weak
);
4074 /* Relax AUIPC + JALR into JAL. */
4077 _bfd_riscv_relax_call (bfd
*abfd
, asection
*sec
, asection
*sym_sec
,
4078 struct bfd_link_info
*link_info
,
4079 Elf_Internal_Rela
*rel
,
4081 bfd_vma max_alignment
,
4082 bfd_vma reserve_size ATTRIBUTE_UNUSED
,
4084 riscv_pcgp_relocs
*pcgp_relocs ATTRIBUTE_UNUSED
,
4085 bfd_boolean undefined_weak ATTRIBUTE_UNUSED
)
4087 bfd_byte
*contents
= elf_section_data (sec
)->this_hdr
.contents
;
4088 bfd_vma foff
= symval
- (sec_addr (sec
) + rel
->r_offset
);
4089 bfd_boolean near_zero
= (symval
+ RISCV_IMM_REACH
/2) < RISCV_IMM_REACH
;
4090 bfd_vma auipc
, jalr
;
4091 int rd
, r_type
, len
= 4, rvc
= elf_elfheader (abfd
)->e_flags
& EF_RISCV_RVC
;
4093 /* If the call crosses section boundaries, an alignment directive could
4094 cause the PC-relative offset to later increase, so we need to add in the
4095 max alignment of any section inclusive from the call to the target.
4096 Otherwise, we only need to use the alignment of the current section. */
4097 if (VALID_UJTYPE_IMM (foff
))
4099 if (sym_sec
->output_section
== sec
->output_section
4100 && sym_sec
->output_section
!= bfd_abs_section_ptr
)
4101 max_alignment
= (bfd_vma
) 1 << sym_sec
->output_section
->alignment_power
;
4102 foff
+= ((bfd_signed_vma
) foff
< 0 ? -max_alignment
: max_alignment
);
4105 /* See if this function call can be shortened. */
4106 if (!VALID_UJTYPE_IMM (foff
) && !(!bfd_link_pic (link_info
) && near_zero
))
4109 /* Shorten the function call. */
4110 BFD_ASSERT (rel
->r_offset
+ 8 <= sec
->size
);
4112 auipc
= bfd_get_32 (abfd
, contents
+ rel
->r_offset
);
4113 jalr
= bfd_get_32 (abfd
, contents
+ rel
->r_offset
+ 4);
4114 rd
= (jalr
>> OP_SH_RD
) & OP_MASK_RD
;
4115 rvc
= rvc
&& VALID_RVC_J_IMM (foff
);
4117 /* C.J exists on RV32 and RV64, but C.JAL is RV32-only. */
4118 rvc
= rvc
&& (rd
== 0 || (rd
== X_RA
&& ARCH_SIZE
== 32));
4122 /* Relax to C.J[AL] rd, addr. */
4123 r_type
= R_RISCV_RVC_JUMP
;
4124 auipc
= rd
== 0 ? MATCH_C_J
: MATCH_C_JAL
;
4127 else if (VALID_UJTYPE_IMM (foff
))
4129 /* Relax to JAL rd, addr. */
4130 r_type
= R_RISCV_JAL
;
4131 auipc
= MATCH_JAL
| (rd
<< OP_SH_RD
);
4133 else /* near_zero */
4135 /* Relax to JALR rd, x0, addr. */
4136 r_type
= R_RISCV_LO12_I
;
4137 auipc
= MATCH_JALR
| (rd
<< OP_SH_RD
);
4140 /* Replace the R_RISCV_CALL reloc. */
4141 rel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (rel
->r_info
), r_type
);
4142 /* Replace the AUIPC. */
4143 bfd_put (8 * len
, abfd
, auipc
, contents
+ rel
->r_offset
);
4145 /* Delete unnecessary JALR. */
4147 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
+ len
, 8 - len
,
4151 /* Traverse all output sections and return the max alignment. */
4154 _bfd_riscv_get_max_alignment (asection
*sec
)
4156 unsigned int max_alignment_power
= 0;
4159 for (o
= sec
->output_section
->owner
->sections
; o
!= NULL
; o
= o
->next
)
4161 if (o
->alignment_power
> max_alignment_power
)
4162 max_alignment_power
= o
->alignment_power
;
4165 return (bfd_vma
) 1 << max_alignment_power
;
4168 /* Relax non-PIC global variable references. */
4171 _bfd_riscv_relax_lui (bfd
*abfd
,
4174 struct bfd_link_info
*link_info
,
4175 Elf_Internal_Rela
*rel
,
4177 bfd_vma max_alignment
,
4178 bfd_vma reserve_size
,
4180 riscv_pcgp_relocs
*pcgp_relocs ATTRIBUTE_UNUSED
,
4181 bfd_boolean undefined_weak
)
4183 bfd_byte
*contents
= elf_section_data (sec
)->this_hdr
.contents
;
4184 bfd_vma gp
= riscv_global_pointer_value (link_info
);
4185 int use_rvc
= elf_elfheader (abfd
)->e_flags
& EF_RISCV_RVC
;
4187 BFD_ASSERT (rel
->r_offset
+ 4 <= sec
->size
);
4191 /* If gp and the symbol are in the same output section, which is not the
4192 abs section, then consider only that output section's alignment. */
4193 struct bfd_link_hash_entry
*h
=
4194 bfd_link_hash_lookup (link_info
->hash
, RISCV_GP_SYMBOL
, FALSE
, FALSE
,
4196 if (h
->u
.def
.section
->output_section
== sym_sec
->output_section
4197 && sym_sec
->output_section
!= bfd_abs_section_ptr
)
4198 max_alignment
= (bfd_vma
) 1 << sym_sec
->output_section
->alignment_power
;
4201 /* Is the reference in range of x0 or gp?
4202 Valid gp range conservatively because of alignment issue. */
4204 || (VALID_ITYPE_IMM (symval
)
4206 && VALID_ITYPE_IMM (symval
- gp
+ max_alignment
+ reserve_size
))
4208 && VALID_ITYPE_IMM (symval
- gp
- max_alignment
- reserve_size
))))
4210 unsigned sym
= ELFNN_R_SYM (rel
->r_info
);
4211 switch (ELFNN_R_TYPE (rel
->r_info
))
4213 case R_RISCV_LO12_I
:
4216 /* Change the RS1 to zero. */
4217 bfd_vma insn
= bfd_get_32 (abfd
, contents
+ rel
->r_offset
);
4218 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
4219 bfd_put_32 (abfd
, insn
, contents
+ rel
->r_offset
);
4222 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_GPREL_I
);
4225 case R_RISCV_LO12_S
:
4228 /* Change the RS1 to zero. */
4229 bfd_vma insn
= bfd_get_32 (abfd
, contents
+ rel
->r_offset
);
4230 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
4231 bfd_put_32 (abfd
, insn
, contents
+ rel
->r_offset
);
4234 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_GPREL_S
);
4238 /* We can delete the unnecessary LUI and reloc. */
4239 rel
->r_info
= ELFNN_R_INFO (0, R_RISCV_NONE
);
4241 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
, 4,
4249 /* Can we relax LUI to C.LUI? Alignment might move the section forward;
4250 account for this assuming page alignment at worst. In the presence of
4251 RELRO segment the linker aligns it by one page size, therefore sections
4252 after the segment can be moved more than one page. */
4255 && ELFNN_R_TYPE (rel
->r_info
) == R_RISCV_HI20
4256 && VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (symval
))
4257 && VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (symval
)
4258 + (link_info
->relro
? 2 * ELF_MAXPAGESIZE
4259 : ELF_MAXPAGESIZE
)))
4261 /* Replace LUI with C.LUI if legal (i.e., rd != x0 and rd != x2/sp). */
4262 bfd_vma lui
= bfd_get_32 (abfd
, contents
+ rel
->r_offset
);
4263 unsigned rd
= ((unsigned)lui
>> OP_SH_RD
) & OP_MASK_RD
;
4264 if (rd
== 0 || rd
== X_SP
)
4267 lui
= (lui
& (OP_MASK_RD
<< OP_SH_RD
)) | MATCH_C_LUI
;
4268 bfd_put_32 (abfd
, lui
, contents
+ rel
->r_offset
);
4270 /* Replace the R_RISCV_HI20 reloc. */
4271 rel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (rel
->r_info
), R_RISCV_RVC_LUI
);
4274 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
+ 2, 2,
4281 /* Relax non-PIC TLS references. */
4284 _bfd_riscv_relax_tls_le (bfd
*abfd
,
4286 asection
*sym_sec ATTRIBUTE_UNUSED
,
4287 struct bfd_link_info
*link_info
,
4288 Elf_Internal_Rela
*rel
,
4290 bfd_vma max_alignment ATTRIBUTE_UNUSED
,
4291 bfd_vma reserve_size ATTRIBUTE_UNUSED
,
4293 riscv_pcgp_relocs
*prcel_relocs ATTRIBUTE_UNUSED
,
4294 bfd_boolean undefined_weak ATTRIBUTE_UNUSED
)
4296 /* See if this symbol is in range of tp. */
4297 if (RISCV_CONST_HIGH_PART (tpoff (link_info
, symval
)) != 0)
4300 BFD_ASSERT (rel
->r_offset
+ 4 <= sec
->size
);
4301 switch (ELFNN_R_TYPE (rel
->r_info
))
4303 case R_RISCV_TPREL_LO12_I
:
4304 rel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (rel
->r_info
), R_RISCV_TPREL_I
);
4307 case R_RISCV_TPREL_LO12_S
:
4308 rel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (rel
->r_info
), R_RISCV_TPREL_S
);
4311 case R_RISCV_TPREL_HI20
:
4312 case R_RISCV_TPREL_ADD
:
4313 /* We can delete the unnecessary instruction and reloc. */
4314 rel
->r_info
= ELFNN_R_INFO (0, R_RISCV_NONE
);
4316 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
, 4, link_info
);
4323 /* Implement R_RISCV_ALIGN by deleting excess alignment NOPs. */
4326 _bfd_riscv_relax_align (bfd
*abfd
, asection
*sec
,
4328 struct bfd_link_info
*link_info
,
4329 Elf_Internal_Rela
*rel
,
4331 bfd_vma max_alignment ATTRIBUTE_UNUSED
,
4332 bfd_vma reserve_size ATTRIBUTE_UNUSED
,
4333 bfd_boolean
*again ATTRIBUTE_UNUSED
,
4334 riscv_pcgp_relocs
*pcrel_relocs ATTRIBUTE_UNUSED
,
4335 bfd_boolean undefined_weak ATTRIBUTE_UNUSED
)
4337 bfd_byte
*contents
= elf_section_data (sec
)->this_hdr
.contents
;
4338 bfd_vma alignment
= 1, pos
;
4339 while (alignment
<= rel
->r_addend
)
4342 symval
-= rel
->r_addend
;
4343 bfd_vma aligned_addr
= ((symval
- 1) & ~(alignment
- 1)) + alignment
;
4344 bfd_vma nop_bytes
= aligned_addr
- symval
;
4346 /* Once we've handled an R_RISCV_ALIGN, we can't relax anything else. */
4347 sec
->sec_flg0
= TRUE
;
4349 /* Make sure there are enough NOPs to actually achieve the alignment. */
4350 if (rel
->r_addend
< nop_bytes
)
4353 (_("%pB(%pA+%#" PRIx64
"): %" PRId64
" bytes required for alignment "
4354 "to %" PRId64
"-byte boundary, but only %" PRId64
" present"),
4355 abfd
, sym_sec
, (uint64_t) rel
->r_offset
,
4356 (int64_t) nop_bytes
, (int64_t) alignment
, (int64_t) rel
->r_addend
);
4357 bfd_set_error (bfd_error_bad_value
);
4361 /* Delete the reloc. */
4362 rel
->r_info
= ELFNN_R_INFO (0, R_RISCV_NONE
);
4364 /* If the number of NOPs is already correct, there's nothing to do. */
4365 if (nop_bytes
== rel
->r_addend
)
4368 /* Write as many RISC-V NOPs as we need. */
4369 for (pos
= 0; pos
< (nop_bytes
& -4); pos
+= 4)
4370 bfd_put_32 (abfd
, RISCV_NOP
, contents
+ rel
->r_offset
+ pos
);
4372 /* Write a final RVC NOP if need be. */
4373 if (nop_bytes
% 4 != 0)
4374 bfd_put_16 (abfd
, RVC_NOP
, contents
+ rel
->r_offset
+ pos
);
4376 /* Delete the excess bytes. */
4377 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
+ nop_bytes
,
4378 rel
->r_addend
- nop_bytes
, link_info
);
4381 /* Relax PC-relative references to GP-relative references. */
4384 _bfd_riscv_relax_pc (bfd
*abfd ATTRIBUTE_UNUSED
,
4387 struct bfd_link_info
*link_info
,
4388 Elf_Internal_Rela
*rel
,
4390 bfd_vma max_alignment
,
4391 bfd_vma reserve_size
,
4392 bfd_boolean
*again ATTRIBUTE_UNUSED
,
4393 riscv_pcgp_relocs
*pcgp_relocs
,
4394 bfd_boolean undefined_weak
)
4396 bfd_byte
*contents
= elf_section_data (sec
)->this_hdr
.contents
;
4397 bfd_vma gp
= riscv_global_pointer_value (link_info
);
4399 BFD_ASSERT (rel
->r_offset
+ 4 <= sec
->size
);
4401 /* Chain the _LO relocs to their cooresponding _HI reloc to compute the
4402 * actual target address. */
4403 riscv_pcgp_hi_reloc hi_reloc
;
4404 memset (&hi_reloc
, 0, sizeof (hi_reloc
));
4405 switch (ELFNN_R_TYPE (rel
->r_info
))
4407 case R_RISCV_PCREL_LO12_I
:
4408 case R_RISCV_PCREL_LO12_S
:
4410 /* If the %lo has an addend, it isn't for the label pointing at the
4411 hi part instruction, but rather for the symbol pointed at by the
4412 hi part instruction. So we must subtract it here for the lookup.
4413 It is still used below in the final symbol address. */
4414 bfd_vma hi_sec_off
= symval
- sec_addr (sym_sec
) - rel
->r_addend
;
4415 riscv_pcgp_hi_reloc
*hi
= riscv_find_pcgp_hi_reloc (pcgp_relocs
,
4419 riscv_record_pcgp_lo_reloc (pcgp_relocs
, hi_sec_off
);
4424 symval
= hi_reloc
.hi_addr
;
4425 sym_sec
= hi_reloc
.sym_sec
;
4427 /* We can not know whether the undefined weak symbol is referenced
4428 according to the information of R_RISCV_PCREL_LO12_I/S. Therefore,
4429 we have to record the 'undefined_weak' flag when handling the
4430 corresponding R_RISCV_HI20 reloc in riscv_record_pcgp_hi_reloc. */
4431 undefined_weak
= hi_reloc
.undefined_weak
;
4435 case R_RISCV_PCREL_HI20
:
4436 /* Mergeable symbols and code might later move out of range. */
4437 if (! undefined_weak
4438 && sym_sec
->flags
& (SEC_MERGE
| SEC_CODE
))
4441 /* If the cooresponding lo relocation has already been seen then it's not
4442 * safe to relax this relocation. */
4443 if (riscv_find_pcgp_lo_reloc (pcgp_relocs
, rel
->r_offset
))
4454 /* If gp and the symbol are in the same output section, which is not the
4455 abs section, then consider only that output section's alignment. */
4456 struct bfd_link_hash_entry
*h
=
4457 bfd_link_hash_lookup (link_info
->hash
, RISCV_GP_SYMBOL
, FALSE
, FALSE
,
4459 if (h
->u
.def
.section
->output_section
== sym_sec
->output_section
4460 && sym_sec
->output_section
!= bfd_abs_section_ptr
)
4461 max_alignment
= (bfd_vma
) 1 << sym_sec
->output_section
->alignment_power
;
4464 /* Is the reference in range of x0 or gp?
4465 Valid gp range conservatively because of alignment issue. */
4467 || (VALID_ITYPE_IMM (symval
)
4469 && VALID_ITYPE_IMM (symval
- gp
+ max_alignment
+ reserve_size
))
4471 && VALID_ITYPE_IMM (symval
- gp
- max_alignment
- reserve_size
))))
4473 unsigned sym
= hi_reloc
.hi_sym
;
4474 switch (ELFNN_R_TYPE (rel
->r_info
))
4476 case R_RISCV_PCREL_LO12_I
:
4479 /* Change the RS1 to zero, and then modify the relocation
4480 type to R_RISCV_LO12_I. */
4481 bfd_vma insn
= bfd_get_32 (abfd
, contents
+ rel
->r_offset
);
4482 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
4483 bfd_put_32 (abfd
, insn
, contents
+ rel
->r_offset
);
4484 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_LO12_I
);
4485 rel
->r_addend
= hi_reloc
.hi_addend
;
4489 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_GPREL_I
);
4490 rel
->r_addend
+= hi_reloc
.hi_addend
;
4494 case R_RISCV_PCREL_LO12_S
:
4497 /* Change the RS1 to zero, and then modify the relocation
4498 type to R_RISCV_LO12_S. */
4499 bfd_vma insn
= bfd_get_32 (abfd
, contents
+ rel
->r_offset
);
4500 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
4501 bfd_put_32 (abfd
, insn
, contents
+ rel
->r_offset
);
4502 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_LO12_S
);
4503 rel
->r_addend
= hi_reloc
.hi_addend
;
4507 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_GPREL_S
);
4508 rel
->r_addend
+= hi_reloc
.hi_addend
;
4512 case R_RISCV_PCREL_HI20
:
4513 riscv_record_pcgp_hi_reloc (pcgp_relocs
,
4517 ELFNN_R_SYM(rel
->r_info
),
4520 /* We can delete the unnecessary AUIPC and reloc. */
4521 rel
->r_info
= ELFNN_R_INFO (0, R_RISCV_DELETE
);
4533 /* Relax PC-relative references to GP-relative references. */
4536 _bfd_riscv_relax_delete (bfd
*abfd
,
4538 asection
*sym_sec ATTRIBUTE_UNUSED
,
4539 struct bfd_link_info
*link_info
,
4540 Elf_Internal_Rela
*rel
,
4541 bfd_vma symval ATTRIBUTE_UNUSED
,
4542 bfd_vma max_alignment ATTRIBUTE_UNUSED
,
4543 bfd_vma reserve_size ATTRIBUTE_UNUSED
,
4544 bfd_boolean
*again ATTRIBUTE_UNUSED
,
4545 riscv_pcgp_relocs
*pcgp_relocs ATTRIBUTE_UNUSED
,
4546 bfd_boolean undefined_weak ATTRIBUTE_UNUSED
)
4548 if (!riscv_relax_delete_bytes(abfd
, sec
, rel
->r_offset
, rel
->r_addend
,
4551 rel
->r_info
= ELFNN_R_INFO(0, R_RISCV_NONE
);
4555 /* Relax a section. Pass 0 shortens code sequences unless disabled. Pass 1
4556 deletes the bytes that pass 0 made obselete. Pass 2, which cannot be
4557 disabled, handles code alignment directives. */
4560 _bfd_riscv_relax_section (bfd
*abfd
, asection
*sec
,
4561 struct bfd_link_info
*info
,
4564 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (abfd
);
4565 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
4566 struct bfd_elf_section_data
*data
= elf_section_data (sec
);
4567 Elf_Internal_Rela
*relocs
;
4568 bfd_boolean ret
= FALSE
;
4570 bfd_vma max_alignment
, reserve_size
= 0;
4571 riscv_pcgp_relocs pcgp_relocs
;
4575 if (bfd_link_relocatable (info
)
4577 || (sec
->flags
& SEC_RELOC
) == 0
4578 || sec
->reloc_count
== 0
4579 || (info
->disable_target_specific_optimizations
4580 && info
->relax_pass
< 2))
4583 riscv_init_pcgp_relocs (&pcgp_relocs
);
4585 /* Read this BFD's relocs if we haven't done so already. */
4587 relocs
= data
->relocs
;
4588 else if (!(relocs
= _bfd_elf_link_read_relocs (abfd
, sec
, NULL
, NULL
,
4589 info
->keep_memory
)))
4594 max_alignment
= htab
->max_alignment
;
4595 if (max_alignment
== (bfd_vma
) -1)
4597 max_alignment
= _bfd_riscv_get_max_alignment (sec
);
4598 htab
->max_alignment
= max_alignment
;
4602 max_alignment
= _bfd_riscv_get_max_alignment (sec
);
4604 /* Examine and consider relaxing each reloc. */
4605 for (i
= 0; i
< sec
->reloc_count
; i
++)
4608 Elf_Internal_Rela
*rel
= relocs
+ i
;
4609 relax_func_t relax_func
;
4610 int type
= ELFNN_R_TYPE (rel
->r_info
);
4613 bfd_boolean undefined_weak
= FALSE
;
4616 if (info
->relax_pass
== 0)
4618 if (type
== R_RISCV_CALL
4619 || type
== R_RISCV_CALL_PLT
)
4620 relax_func
= _bfd_riscv_relax_call
;
4621 else if (type
== R_RISCV_HI20
4622 || type
== R_RISCV_LO12_I
4623 || type
== R_RISCV_LO12_S
)
4624 relax_func
= _bfd_riscv_relax_lui
;
4625 else if (type
== R_RISCV_TPREL_HI20
4626 || type
== R_RISCV_TPREL_ADD
4627 || type
== R_RISCV_TPREL_LO12_I
4628 || type
== R_RISCV_TPREL_LO12_S
)
4629 relax_func
= _bfd_riscv_relax_tls_le
;
4633 else if (info
->relax_pass
== 1
4634 && !bfd_link_pic(info
)
4635 && (type
== R_RISCV_PCREL_HI20
4636 || type
== R_RISCV_PCREL_LO12_I
4637 || type
== R_RISCV_PCREL_LO12_S
))
4638 relax_func
= _bfd_riscv_relax_pc
;
4639 else if (info
->relax_pass
== 2 && type
== R_RISCV_DELETE
)
4640 relax_func
= _bfd_riscv_relax_delete
;
4641 else if (info
->relax_pass
== 3 && type
== R_RISCV_ALIGN
)
4642 relax_func
= _bfd_riscv_relax_align
;
4646 if (info
->relax_pass
< 2)
4648 /* Only relax this reloc if it is paired with R_RISCV_RELAX. */
4649 if (i
== sec
->reloc_count
- 1
4650 || ELFNN_R_TYPE ((rel
+ 1)->r_info
) != R_RISCV_RELAX
4651 || rel
->r_offset
!= (rel
+ 1)->r_offset
)
4654 /* Skip over the R_RISCV_RELAX. */
4658 data
->relocs
= relocs
;
4660 /* Read this BFD's contents if we haven't done so already. */
4661 if (!data
->this_hdr
.contents
4662 && !bfd_malloc_and_get_section (abfd
, sec
, &data
->this_hdr
.contents
))
4665 /* Read this BFD's symbols if we haven't done so already. */
4666 if (symtab_hdr
->sh_info
!= 0
4667 && !symtab_hdr
->contents
4668 && !(symtab_hdr
->contents
=
4669 (unsigned char *) bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
4670 symtab_hdr
->sh_info
,
4671 0, NULL
, NULL
, NULL
)))
4674 /* Get the value of the symbol referred to by the reloc. */
4675 if (ELFNN_R_SYM (rel
->r_info
) < symtab_hdr
->sh_info
)
4677 /* A local symbol. */
4678 Elf_Internal_Sym
*isym
= ((Elf_Internal_Sym
*) symtab_hdr
->contents
4679 + ELFNN_R_SYM (rel
->r_info
));
4680 reserve_size
= (isym
->st_size
- rel
->r_addend
) > isym
->st_size
4681 ? 0 : isym
->st_size
- rel
->r_addend
;
4683 /* Relocate against local STT_GNU_IFUNC symbol. we have created
4684 a fake global symbol entry for this, so deal with the local ifunc
4686 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
4689 if (isym
->st_shndx
== SHN_UNDEF
)
4690 sym_sec
= sec
, symval
= rel
->r_offset
;
4693 BFD_ASSERT (isym
->st_shndx
< elf_numsections (abfd
));
4694 sym_sec
= elf_elfsections (abfd
)[isym
->st_shndx
]->bfd_section
;
4696 /* The purpose of this code is unknown. It breaks linker scripts
4697 for embedded development that place sections at address zero.
4698 This code is believed to be unnecessary. Disabling it but not
4699 yet removing it, in case something breaks. */
4700 if (sec_addr (sym_sec
) == 0)
4703 symval
= isym
->st_value
;
4705 symtype
= ELF_ST_TYPE (isym
->st_info
);
4710 struct elf_link_hash_entry
*h
;
4712 indx
= ELFNN_R_SYM (rel
->r_info
) - symtab_hdr
->sh_info
;
4713 h
= elf_sym_hashes (abfd
)[indx
];
4715 while (h
->root
.type
== bfd_link_hash_indirect
4716 || h
->root
.type
== bfd_link_hash_warning
)
4717 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
4719 /* Disable the relaxation for ifunc. */
4720 if (h
!= NULL
&& h
->type
== STT_GNU_IFUNC
)
4723 if (h
->root
.type
== bfd_link_hash_undefweak
4724 && (relax_func
== _bfd_riscv_relax_lui
4725 || relax_func
== _bfd_riscv_relax_pc
))
4727 /* For the lui and auipc relaxations, since the symbol
4728 value of an undefined weak symbol is always be zero,
4729 we can optimize the patterns into a single LI/MV/ADDI
4732 Note that, creating shared libraries and pie output may
4733 break the rule above. Fortunately, since we do not relax
4734 pc relocs when creating shared libraries and pie output,
4735 and the absolute address access for R_RISCV_HI20 isn't
4736 allowed when "-fPIC" is set, the problem of creating shared
4737 libraries can not happen currently. Once we support the
4738 auipc relaxations when creating shared libraries, then we will
4739 need the more rigorous checking for this optimization. */
4740 undefined_weak
= TRUE
;
4743 /* This line has to match the check in riscv_elf_relocate_section
4744 in the R_RISCV_CALL[_PLT] case. */
4745 if (bfd_link_pic (info
) && h
->plt
.offset
!= MINUS_ONE
)
4747 sym_sec
= htab
->elf
.splt
;
4748 symval
= h
->plt
.offset
;
4750 else if (undefined_weak
)
4753 sym_sec
= bfd_und_section_ptr
;
4755 else if ((h
->root
.type
== bfd_link_hash_defined
4756 || h
->root
.type
== bfd_link_hash_defweak
)
4757 && h
->root
.u
.def
.section
!= NULL
4758 && h
->root
.u
.def
.section
->output_section
!= NULL
)
4760 symval
= h
->root
.u
.def
.value
;
4761 sym_sec
= h
->root
.u
.def
.section
;
4766 if (h
->type
!= STT_FUNC
)
4768 (h
->size
- rel
->r_addend
) > h
->size
? 0 : h
->size
- rel
->r_addend
;
4772 if (sym_sec
->sec_info_type
== SEC_INFO_TYPE_MERGE
4773 && (sym_sec
->flags
& SEC_MERGE
))
4775 /* At this stage in linking, no SEC_MERGE symbol has been
4776 adjusted, so all references to such symbols need to be
4777 passed through _bfd_merged_section_offset. (Later, in
4778 relocate_section, all SEC_MERGE symbols *except* for
4779 section symbols have been adjusted.)
4781 gas may reduce relocations against symbols in SEC_MERGE
4782 sections to a relocation against the section symbol when
4783 the original addend was zero. When the reloc is against
4784 a section symbol we should include the addend in the
4785 offset passed to _bfd_merged_section_offset, since the
4786 location of interest is the original symbol. On the
4787 other hand, an access to "sym+addend" where "sym" is not
4788 a section symbol should not include the addend; Such an
4789 access is presumed to be an offset from "sym"; The
4790 location of interest is just "sym". */
4791 if (symtype
== STT_SECTION
)
4792 symval
+= rel
->r_addend
;
4794 symval
= _bfd_merged_section_offset (abfd
, &sym_sec
,
4795 elf_section_data (sym_sec
)->sec_info
,
4798 if (symtype
!= STT_SECTION
)
4799 symval
+= rel
->r_addend
;
4802 symval
+= rel
->r_addend
;
4804 symval
+= sec_addr (sym_sec
);
4806 if (!relax_func (abfd
, sec
, sym_sec
, info
, rel
, symval
,
4807 max_alignment
, reserve_size
, again
,
4808 &pcgp_relocs
, undefined_weak
))
4815 if (relocs
!= data
->relocs
)
4817 riscv_free_pcgp_relocs(&pcgp_relocs
, abfd
, sec
);
4823 # define PRSTATUS_SIZE 204
4824 # define PRSTATUS_OFFSET_PR_CURSIG 12
4825 # define PRSTATUS_OFFSET_PR_PID 24
4826 # define PRSTATUS_OFFSET_PR_REG 72
4827 # define ELF_GREGSET_T_SIZE 128
4828 # define PRPSINFO_SIZE 128
4829 # define PRPSINFO_OFFSET_PR_PID 16
4830 # define PRPSINFO_OFFSET_PR_FNAME 32
4831 # define PRPSINFO_OFFSET_PR_PSARGS 48
4833 # define PRSTATUS_SIZE 376
4834 # define PRSTATUS_OFFSET_PR_CURSIG 12
4835 # define PRSTATUS_OFFSET_PR_PID 32
4836 # define PRSTATUS_OFFSET_PR_REG 112
4837 # define ELF_GREGSET_T_SIZE 256
4838 # define PRPSINFO_SIZE 136
4839 # define PRPSINFO_OFFSET_PR_PID 24
4840 # define PRPSINFO_OFFSET_PR_FNAME 40
4841 # define PRPSINFO_OFFSET_PR_PSARGS 56
4844 /* Support for core dump NOTE sections. */
4847 riscv_elf_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
4849 switch (note
->descsz
)
4854 case PRSTATUS_SIZE
: /* sizeof(struct elf_prstatus) on Linux/RISC-V. */
4856 elf_tdata (abfd
)->core
->signal
4857 = bfd_get_16 (abfd
, note
->descdata
+ PRSTATUS_OFFSET_PR_CURSIG
);
4860 elf_tdata (abfd
)->core
->lwpid
4861 = bfd_get_32 (abfd
, note
->descdata
+ PRSTATUS_OFFSET_PR_PID
);
4865 /* Make a ".reg/999" section. */
4866 return _bfd_elfcore_make_pseudosection (abfd
, ".reg", ELF_GREGSET_T_SIZE
,
4867 note
->descpos
+ PRSTATUS_OFFSET_PR_REG
);
4871 riscv_elf_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
4873 switch (note
->descsz
)
4878 case PRPSINFO_SIZE
: /* sizeof(struct elf_prpsinfo) on Linux/RISC-V. */
4880 elf_tdata (abfd
)->core
->pid
4881 = bfd_get_32 (abfd
, note
->descdata
+ PRPSINFO_OFFSET_PR_PID
);
4884 elf_tdata (abfd
)->core
->program
= _bfd_elfcore_strndup
4885 (abfd
, note
->descdata
+ PRPSINFO_OFFSET_PR_FNAME
, 16);
4888 elf_tdata (abfd
)->core
->command
= _bfd_elfcore_strndup
4889 (abfd
, note
->descdata
+ PRPSINFO_OFFSET_PR_PSARGS
, 80);
4893 /* Note that for some reason, a spurious space is tacked
4894 onto the end of the args in some (at least one anyway)
4895 implementations, so strip it off if it exists. */
4898 char *command
= elf_tdata (abfd
)->core
->command
;
4899 int n
= strlen (command
);
4901 if (0 < n
&& command
[n
- 1] == ' ')
4902 command
[n
- 1] = '\0';
4908 /* Set the right mach type. */
4910 riscv_elf_object_p (bfd
*abfd
)
4912 /* There are only two mach types in RISCV currently. */
4913 if (strcmp (abfd
->xvec
->name
, "elf32-littleriscv") == 0)
4914 bfd_default_set_arch_mach (abfd
, bfd_arch_riscv
, bfd_mach_riscv32
);
4916 bfd_default_set_arch_mach (abfd
, bfd_arch_riscv
, bfd_mach_riscv64
);
4921 /* Determine whether an object attribute tag takes an integer, a
4925 riscv_elf_obj_attrs_arg_type (int tag
)
4927 return (tag
& 1) != 0 ? ATTR_TYPE_FLAG_STR_VAL
: ATTR_TYPE_FLAG_INT_VAL
;
4930 #define TARGET_LITTLE_SYM riscv_elfNN_vec
4931 #define TARGET_LITTLE_NAME "elfNN-littleriscv"
4933 #define elf_backend_reloc_type_class riscv_reloc_type_class
4935 #define bfd_elfNN_bfd_reloc_name_lookup riscv_reloc_name_lookup
4936 #define bfd_elfNN_bfd_link_hash_table_create riscv_elf_link_hash_table_create
4937 #define bfd_elfNN_bfd_reloc_type_lookup riscv_reloc_type_lookup
4938 #define bfd_elfNN_bfd_merge_private_bfd_data \
4939 _bfd_riscv_elf_merge_private_bfd_data
4941 #define elf_backend_copy_indirect_symbol riscv_elf_copy_indirect_symbol
4942 #define elf_backend_create_dynamic_sections riscv_elf_create_dynamic_sections
4943 #define elf_backend_check_relocs riscv_elf_check_relocs
4944 #define elf_backend_adjust_dynamic_symbol riscv_elf_adjust_dynamic_symbol
4945 #define elf_backend_size_dynamic_sections riscv_elf_size_dynamic_sections
4946 #define elf_backend_relocate_section riscv_elf_relocate_section
4947 #define elf_backend_finish_dynamic_symbol riscv_elf_finish_dynamic_symbol
4948 #define elf_backend_finish_dynamic_sections riscv_elf_finish_dynamic_sections
4949 #define elf_backend_gc_mark_hook riscv_elf_gc_mark_hook
4950 #define elf_backend_plt_sym_val riscv_elf_plt_sym_val
4951 #define elf_backend_grok_prstatus riscv_elf_grok_prstatus
4952 #define elf_backend_grok_psinfo riscv_elf_grok_psinfo
4953 #define elf_backend_object_p riscv_elf_object_p
4954 #define elf_info_to_howto_rel NULL
4955 #define elf_info_to_howto riscv_info_to_howto_rela
4956 #define bfd_elfNN_bfd_relax_section _bfd_riscv_relax_section
4957 #define bfd_elfNN_mkobject elfNN_riscv_mkobject
4959 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
4961 #define elf_backend_can_gc_sections 1
4962 #define elf_backend_can_refcount 1
4963 #define elf_backend_want_got_plt 1
4964 #define elf_backend_plt_readonly 1
4965 #define elf_backend_plt_alignment 4
4966 #define elf_backend_want_plt_sym 1
4967 #define elf_backend_got_header_size (ARCH_SIZE / 8)
4968 #define elf_backend_want_dynrelro 1
4969 #define elf_backend_rela_normal 1
4970 #define elf_backend_default_execstack 0
4972 #undef elf_backend_obj_attrs_vendor
4973 #define elf_backend_obj_attrs_vendor "riscv"
4974 #undef elf_backend_obj_attrs_arg_type
4975 #define elf_backend_obj_attrs_arg_type riscv_elf_obj_attrs_arg_type
4976 #undef elf_backend_obj_attrs_section_type
4977 #define elf_backend_obj_attrs_section_type SHT_RISCV_ATTRIBUTES
4978 #undef elf_backend_obj_attrs_section
4979 #define elf_backend_obj_attrs_section ".riscv.attributes"
4981 #include "elfNN-target.h"