projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
RISC-V: Add R_RISCV_DELETE, which marks bytes for deletion
[deliverable/binutils-gdb.git] / bfd / elfnn-riscv.c
CommitLineData
e23eba97 1/* RISC-V-specific support for NN-bit ELF.
2571583a 2 Copyright (C) 2011-2017 Free Software Foundation, Inc.
e23eba97
NC		 3
4 Contributed by Andrew Waterman (andrew@sifive.com).
5 Based on TILE-Gx and MIPS targets.
6
7 This file is part of BFD, the Binary File Descriptor library.
8
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.
13
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.
18
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/>. */
22
23/* This file handles RISC-V ELF targets. */
24
25#include "sysdep.h"
26#include "bfd.h"
27#include "libbfd.h"
28#include "bfdlink.h"
29#include "genlink.h"
30#include "elf-bfd.h"
31#include "elfxx-riscv.h"
32#include "elf/riscv.h"
33#include "opcode/riscv.h"
34
ff6f4d9b
PD		 35/* Internal relocations used exclusively by the relaxation pass. */
36#define R_RISCV_DELETE (R_RISCV_max + 1)
37
e23eba97
NC		 38#define ARCH_SIZE NN
39
40#define MINUS_ONE ((bfd_vma)0 - 1)
41
42#define RISCV_ELF_LOG_WORD_BYTES (ARCH_SIZE == 32 ? 2 : 3)
43
44#define RISCV_ELF_WORD_BYTES (1 << RISCV_ELF_LOG_WORD_BYTES)
45
46/* The name of the dynamic interpreter. This is put in the .interp
47 section. */
48
49#define ELF64_DYNAMIC_INTERPRETER "/lib/ld.so.1"
50#define ELF32_DYNAMIC_INTERPRETER "/lib32/ld.so.1"
51
52#define ELF_ARCH bfd_arch_riscv
53#define ELF_TARGET_ID RISCV_ELF_DATA
54#define ELF_MACHINE_CODE EM_RISCV
55#define ELF_MAXPAGESIZE 0x1000
56#define ELF_COMMONPAGESIZE 0x1000
57
58/* The RISC-V linker needs to keep track of the number of relocs that it
59 decides to copy as dynamic relocs in check_relocs for each symbol.
60 This is so that it can later discard them if they are found to be
61 unnecessary. We store the information in a field extending the
62 regular ELF linker hash table. */
63
64struct riscv_elf_dyn_relocs
65{
66 struct riscv_elf_dyn_relocs *next;
67
68 /* The input section of the reloc. */
69 asection *sec;
70
71 /* Total number of relocs copied for the input section. */
72 bfd_size_type count;
73
74 /* Number of pc-relative relocs copied for the input section. */
75 bfd_size_type pc_count;
76};
77
78/* RISC-V ELF linker hash entry. */
79
80struct riscv_elf_link_hash_entry
81{
82 struct elf_link_hash_entry elf;
83
84 /* Track dynamic relocs copied for this symbol. */
85 struct riscv_elf_dyn_relocs *dyn_relocs;
86
87#define GOT_UNKNOWN 0
88#define GOT_NORMAL 1
89#define GOT_TLS_GD 2
90#define GOT_TLS_IE 4
91#define GOT_TLS_LE 8
92 char tls_type;
93};
94
95#define riscv_elf_hash_entry(ent) \
96 ((struct riscv_elf_link_hash_entry *)(ent))
97
98struct _bfd_riscv_elf_obj_tdata
99{
100 struct elf_obj_tdata root;
101
102 /* tls_type for each local got entry. */
103 char *local_got_tls_type;
104};
105
106#define _bfd_riscv_elf_tdata(abfd) \
107 ((struct _bfd_riscv_elf_obj_tdata *) (abfd)->tdata.any)
108
109#define _bfd_riscv_elf_local_got_tls_type(abfd) \
110 (_bfd_riscv_elf_tdata (abfd)->local_got_tls_type)
111
112#define _bfd_riscv_elf_tls_type(abfd, h, symndx) \
113 (*((h) != NULL ? &riscv_elf_hash_entry (h)->tls_type \
114 : &_bfd_riscv_elf_local_got_tls_type (abfd) [symndx]))
115
116#define is_riscv_elf(bfd) \
117 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
118 && elf_tdata (bfd) != NULL \
119 && elf_object_id (bfd) == RISCV_ELF_DATA)
120
121#include "elf/common.h"
122#include "elf/internal.h"
123
124struct riscv_elf_link_hash_table
125{
126 struct elf_link_hash_table elf;
127
128 /* Short-cuts to get to dynamic linker sections. */
e23eba97
NC		 129 asection *sdyntdata;
130
131 /* Small local sym to section mapping cache. */
132 struct sym_cache sym_cache;
fc3c5343
L		 133
134 /* The max alignment of output sections. */
135 bfd_vma max_alignment;
e23eba97
NC		 136};
137
138
139/* Get the RISC-V ELF linker hash table from a link_info structure. */
140#define riscv_elf_hash_table(p) \
141 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
142 == RISCV_ELF_DATA ? ((struct riscv_elf_link_hash_table *) ((p)->hash)) : NULL)
143
144static void
145riscv_info_to_howto_rela (bfd *abfd ATTRIBUTE_UNUSED,
146 arelent *cache_ptr,
147 Elf_Internal_Rela *dst)
148{
149 cache_ptr->howto = riscv_elf_rtype_to_howto (ELFNN_R_TYPE (dst->r_info));
150}
151
152static void
153riscv_elf_append_rela (bfd *abfd, asection *s, Elf_Internal_Rela *rel)
154{
155 const struct elf_backend_data *bed;
156 bfd_byte *loc;
157
158 bed = get_elf_backend_data (abfd);
159 loc = s->contents + (s->reloc_count++ * bed->s->sizeof_rela);
160 bed->s->swap_reloca_out (abfd, rel, loc);
161}
162
163/* PLT/GOT stuff. */
164
165#define PLT_HEADER_INSNS 8
166#define PLT_ENTRY_INSNS 4
167#define PLT_HEADER_SIZE (PLT_HEADER_INSNS * 4)
168#define PLT_ENTRY_SIZE (PLT_ENTRY_INSNS * 4)
169
170#define GOT_ENTRY_SIZE RISCV_ELF_WORD_BYTES
171
172#define GOTPLT_HEADER_SIZE (2 * GOT_ENTRY_SIZE)
173
174#define sec_addr(sec) ((sec)->output_section->vma + (sec)->output_offset)
175
176static bfd_vma
177riscv_elf_got_plt_val (bfd_vma plt_index, struct bfd_link_info *info)
178{
179 return sec_addr (riscv_elf_hash_table (info)->elf.sgotplt)
180 + GOTPLT_HEADER_SIZE + (plt_index * GOT_ENTRY_SIZE);
181}
182
183#if ARCH_SIZE == 32
184# define MATCH_LREG MATCH_LW
185#else
186# define MATCH_LREG MATCH_LD
187#endif
188
189/* Generate a PLT header. */
190
191static void
192riscv_make_plt_header (bfd_vma gotplt_addr, bfd_vma addr, uint32_t *entry)
193{
194 bfd_vma gotplt_offset_high = RISCV_PCREL_HIGH_PART (gotplt_addr, addr);
195 bfd_vma gotplt_offset_low = RISCV_PCREL_LOW_PART (gotplt_addr, addr);
196
197 /* auipc t2, %hi(.got.plt)
198 sub t1, t1, t3 # shifted .got.plt offset + hdr size + 12
199 l[w|d] t3, %lo(.got.plt)(t2) # _dl_runtime_resolve
200 addi t1, t1, -(hdr size + 12) # shifted .got.plt offset
201 addi t0, t2, %lo(.got.plt) # &.got.plt
202 srli t1, t1, log2(16/PTRSIZE) # .got.plt offset
203 l[w|d] t0, PTRSIZE(t0) # link map
204 jr t3 */
205
206 entry[0] = RISCV_UTYPE (AUIPC, X_T2, gotplt_offset_high);
207 entry[1] = RISCV_RTYPE (SUB, X_T1, X_T1, X_T3);
208 entry[2] = RISCV_ITYPE (LREG, X_T3, X_T2, gotplt_offset_low);
209 entry[3] = RISCV_ITYPE (ADDI, X_T1, X_T1, -(PLT_HEADER_SIZE + 12));
210 entry[4] = RISCV_ITYPE (ADDI, X_T0, X_T2, gotplt_offset_low);
211 entry[5] = RISCV_ITYPE (SRLI, X_T1, X_T1, 4 - RISCV_ELF_LOG_WORD_BYTES);
212 entry[6] = RISCV_ITYPE (LREG, X_T0, X_T0, RISCV_ELF_WORD_BYTES);
213 entry[7] = RISCV_ITYPE (JALR, 0, X_T3, 0);
214}
215
216/* Generate a PLT entry. */
217
218static void
219riscv_make_plt_entry (bfd_vma got, bfd_vma addr, uint32_t *entry)
220{
221 /* auipc t3, %hi(.got.plt entry)
222 l[w|d] t3, %lo(.got.plt entry)(t3)
223 jalr t1, t3
224 nop */
225
226 entry[0] = RISCV_UTYPE (AUIPC, X_T3, RISCV_PCREL_HIGH_PART (got, addr));
1d65abb5 227 entry[1] = RISCV_ITYPE (LREG, X_T3, X_T3, RISCV_PCREL_LOW_PART (got, addr));
e23eba97
NC		 228 entry[2] = RISCV_ITYPE (JALR, X_T1, X_T3, 0);
229 entry[3] = RISCV_NOP;
230}
231
232/* Create an entry in an RISC-V ELF linker hash table. */
233
234static struct bfd_hash_entry *
235link_hash_newfunc (struct bfd_hash_entry *entry,
236 struct bfd_hash_table *table, const char *string)
237{
238 /* Allocate the structure if it has not already been allocated by a
239 subclass. */
240 if (entry == NULL)
241 {
242 entry =
243 bfd_hash_allocate (table,
244 sizeof (struct riscv_elf_link_hash_entry));
245 if (entry == NULL)
246 return entry;
247 }
248
249 /* Call the allocation method of the superclass. */
250 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
251 if (entry != NULL)
252 {
253 struct riscv_elf_link_hash_entry *eh;
254
255 eh = (struct riscv_elf_link_hash_entry *) entry;
256 eh->dyn_relocs = NULL;
257 eh->tls_type = GOT_UNKNOWN;
258 }
259
260 return entry;
261}
262
263/* Create a RISC-V ELF linker hash table. */
264
265static struct bfd_link_hash_table *
266riscv_elf_link_hash_table_create (bfd *abfd)
267{
268 struct riscv_elf_link_hash_table *ret;
269 bfd_size_type amt = sizeof (struct riscv_elf_link_hash_table);
270
271 ret = (struct riscv_elf_link_hash_table *) bfd_zmalloc (amt);
272 if (ret == NULL)
273 return NULL;
274
275 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc,
276 sizeof (struct riscv_elf_link_hash_entry),
277 RISCV_ELF_DATA))
278 {
279 free (ret);
280 return NULL;
281 }
282
fc3c5343 283 ret->max_alignment = (bfd_vma) -1;
e23eba97
NC		 284 return &ret->elf.root;
285}
286
287/* Create the .got section. */
288
289static bfd_boolean
290riscv_elf_create_got_section (bfd *abfd, struct bfd_link_info *info)
291{
292 flagword flags;
293 asection *s, *s_got;
294 struct elf_link_hash_entry *h;
295 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
296 struct elf_link_hash_table *htab = elf_hash_table (info);
297
298 /* This function may be called more than once. */
ce558b89 299 if (htab->sgot != NULL)
e23eba97
NC		 300 return TRUE;
301
302 flags = bed->dynamic_sec_flags;
303
304 s = bfd_make_section_anyway_with_flags (abfd,
305 (bed->rela_plts_and_copies_p
306 ? ".rela.got" : ".rel.got"),
307 (bed->dynamic_sec_flags
308 | SEC_READONLY));
309 if (s == NULL
310 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
311 return FALSE;
312 htab->srelgot = s;
313
314 s = s_got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
315 if (s == NULL
316 || !bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
317 return FALSE;
318 htab->sgot = s;
319
320 /* The first bit of the global offset table is the header. */
321 s->size += bed->got_header_size;
322
323 if (bed->want_got_plt)
324 {
325 s = bfd_make_section_anyway_with_flags (abfd, ".got.plt", flags);
326 if (s == NULL
327 || !bfd_set_section_alignment (abfd, s,
328 bed->s->log_file_align))
329 return FALSE;
330 htab->sgotplt = s;
331
332 /* Reserve room for the header. */
333 s->size += GOTPLT_HEADER_SIZE;
334 }
335
336 if (bed->want_got_sym)
337 {
338 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
339 section. We don't do this in the linker script because we don't want
340 to define the symbol if we are not creating a global offset
341 table. */
342 h = _bfd_elf_define_linkage_sym (abfd, info, s_got,
343 "_GLOBAL_OFFSET_TABLE_");
344 elf_hash_table (info)->hgot = h;
345 if (h == NULL)
346 return FALSE;
347 }
348
349 return TRUE;
350}
351
352/* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
353 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
354 hash table. */
355
356static bfd_boolean
357riscv_elf_create_dynamic_sections (bfd *dynobj,
358 struct bfd_link_info *info)
359{
360 struct riscv_elf_link_hash_table *htab;
361
362 htab = riscv_elf_hash_table (info);
363 BFD_ASSERT (htab != NULL);
364
365 if (!riscv_elf_create_got_section (dynobj, info))
366 return FALSE;
367
368 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
369 return FALSE;
370
e23eba97
NC		 371 if (!bfd_link_pic (info))
372 {
e23eba97
NC		 373 htab->sdyntdata =
374 bfd_make_section_anyway_with_flags (dynobj, ".tdata.dyn",
375 SEC_ALLOC | SEC_THREAD_LOCAL);
376 }
377
9d19e4fd
AM		 378 if (!htab->elf.splt || !htab->elf.srelplt || !htab->elf.sdynbss
379 || (!bfd_link_pic (info) && (!htab->elf.srelbss || !htab->sdyntdata)))
e23eba97
NC		 380 abort ();
381
382 return TRUE;
383}
384
385/* Copy the extra info we tack onto an elf_link_hash_entry. */
386
387static void
388riscv_elf_copy_indirect_symbol (struct bfd_link_info *info,
389 struct elf_link_hash_entry *dir,
390 struct elf_link_hash_entry *ind)
391{
392 struct riscv_elf_link_hash_entry *edir, *eind;
393
394 edir = (struct riscv_elf_link_hash_entry *) dir;
395 eind = (struct riscv_elf_link_hash_entry *) ind;
396
397 if (eind->dyn_relocs != NULL)
398 {
399 if (edir->dyn_relocs != NULL)
400 {
401 struct riscv_elf_dyn_relocs **pp;
402 struct riscv_elf_dyn_relocs *p;
403
404 /* Add reloc counts against the indirect sym to the direct sym
405 list. Merge any entries against the same section. */
406 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
407 {
408 struct riscv_elf_dyn_relocs *q;
409
410 for (q = edir->dyn_relocs; q != NULL; q = q->next)
411 if (q->sec == p->sec)
412 {
413 q->pc_count += p->pc_count;
414 q->count += p->count;
415 *pp = p->next;
416 break;
417 }
418 if (q == NULL)
419 pp = &p->next;
420 }
421 *pp = edir->dyn_relocs;
422 }
423
424 edir->dyn_relocs = eind->dyn_relocs;
425 eind->dyn_relocs = NULL;
426 }
427
428 if (ind->root.type == bfd_link_hash_indirect
429 && dir->got.refcount <= 0)
430 {
431 edir->tls_type = eind->tls_type;
432 eind->tls_type = GOT_UNKNOWN;
433 }
434 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
435}
436
437static bfd_boolean
438riscv_elf_record_tls_type (bfd *abfd, struct elf_link_hash_entry *h,
439 unsigned long symndx, char tls_type)
440{
441 char *new_tls_type = &_bfd_riscv_elf_tls_type (abfd, h, symndx);
442
443 *new_tls_type |= tls_type;
444 if ((*new_tls_type & GOT_NORMAL) && (*new_tls_type & ~GOT_NORMAL))
445 {
446 (*_bfd_error_handler)
447 (_("%B: `%s' accessed both as normal and thread local symbol"),
448 abfd, h ? h->root.root.string : "<local>");
449 return FALSE;
450 }
451 return TRUE;
452}
453
454static bfd_boolean
455riscv_elf_record_got_reference (bfd *abfd, struct bfd_link_info *info,
456 struct elf_link_hash_entry *h, long symndx)
457{
458 struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info);
459 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
460
461 if (htab->elf.sgot == NULL)
462 {
463 if (!riscv_elf_create_got_section (htab->elf.dynobj, info))
464 return FALSE;
465 }
466
467 if (h != NULL)
468 {
469 h->got.refcount += 1;
470 return TRUE;
471 }
472
473 /* This is a global offset table entry for a local symbol. */
474 if (elf_local_got_refcounts (abfd) == NULL)
475 {
476 bfd_size_type size = symtab_hdr->sh_info * (sizeof (bfd_vma) + 1);
477 if (!(elf_local_got_refcounts (abfd) = bfd_zalloc (abfd, size)))
478 return FALSE;
479 _bfd_riscv_elf_local_got_tls_type (abfd)
480 = (char *) (elf_local_got_refcounts (abfd) + symtab_hdr->sh_info);
481 }
482 elf_local_got_refcounts (abfd) [symndx] += 1;
483
484 return TRUE;
485}
486
487static bfd_boolean
488bad_static_reloc (bfd *abfd, unsigned r_type, struct elf_link_hash_entry *h)
489{
490 (*_bfd_error_handler)
491 (_("%B: relocation %s against `%s' can not be used when making a shared "
492 "object; recompile with -fPIC"),
493 abfd, riscv_elf_rtype_to_howto (r_type)->name,
494 h != NULL ? h->root.root.string : "a local symbol");
495 bfd_set_error (bfd_error_bad_value);
496 return FALSE;
497}
498/* Look through the relocs for a section during the first phase, and
499 allocate space in the global offset table or procedure linkage
500 table. */
501
502static bfd_boolean
503riscv_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
504 asection *sec, const Elf_Internal_Rela *relocs)
505{
506 struct riscv_elf_link_hash_table *htab;
507 Elf_Internal_Shdr *symtab_hdr;
508 struct elf_link_hash_entry **sym_hashes;
509 const Elf_Internal_Rela *rel;
510 asection *sreloc = NULL;
511
512 if (bfd_link_relocatable (info))
513 return TRUE;
514
515 htab = riscv_elf_hash_table (info);
516 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
517 sym_hashes = elf_sym_hashes (abfd);
518
519 if (htab->elf.dynobj == NULL)
520 htab->elf.dynobj = abfd;
521
522 for (rel = relocs; rel < relocs + sec->reloc_count; rel++)
523 {
524 unsigned int r_type;
d42c267e 525 unsigned int r_symndx;
e23eba97
NC		 526 struct elf_link_hash_entry *h;
527
528 r_symndx = ELFNN_R_SYM (rel->r_info);
529 r_type = ELFNN_R_TYPE (rel->r_info);
530
531 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
532 {
533 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
534 abfd, r_symndx);
535 return FALSE;
536 }
537
538 if (r_symndx < symtab_hdr->sh_info)
539 h = NULL;
540 else
541 {
542 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
543 while (h->root.type == bfd_link_hash_indirect
544 || h->root.type == bfd_link_hash_warning)
545 h = (struct elf_link_hash_entry *) h->root.u.i.link;
546
547 /* PR15323, ref flags aren't set for references in the same
548 object. */
bc4e12de 549 h->root.non_ir_ref_regular = 1;
e23eba97
NC		 550 }
551
552 switch (r_type)
553 {
554 case R_RISCV_TLS_GD_HI20:
555 if (!riscv_elf_record_got_reference (abfd, info, h, r_symndx)
556 || !riscv_elf_record_tls_type (abfd, h, r_symndx, GOT_TLS_GD))
557 return FALSE;
558 break;
559
560 case R_RISCV_TLS_GOT_HI20:
561 if (bfd_link_pic (info))
562 info->flags |= DF_STATIC_TLS;
563 if (!riscv_elf_record_got_reference (abfd, info, h, r_symndx)
564 || !riscv_elf_record_tls_type (abfd, h, r_symndx, GOT_TLS_IE))
565 return FALSE;
566 break;
567
568 case R_RISCV_GOT_HI20:
569 if (!riscv_elf_record_got_reference (abfd, info, h, r_symndx)
570 || !riscv_elf_record_tls_type (abfd, h, r_symndx, GOT_NORMAL))
571 return FALSE;
572 break;
573
574 case R_RISCV_CALL_PLT:
575 /* This symbol requires a procedure linkage table entry. We
576 actually build the entry in adjust_dynamic_symbol,
577 because this might be a case of linking PIC code without
578 linking in any dynamic objects, in which case we don't
579 need to generate a procedure linkage table after all. */
580
581 if (h != NULL)
582 {
583 h->needs_plt = 1;
584 h->plt.refcount += 1;
585 }
586 break;
587
588 case R_RISCV_CALL:
589 case R_RISCV_JAL:
590 case R_RISCV_BRANCH:
591 case R_RISCV_RVC_BRANCH:
592 case R_RISCV_RVC_JUMP:
593 case R_RISCV_PCREL_HI20:
594 /* In shared libraries, these relocs are known to bind locally. */
595 if (bfd_link_pic (info))
596 break;
597 goto static_reloc;
598
599 case R_RISCV_TPREL_HI20:
600 if (!bfd_link_executable (info))
601 return bad_static_reloc (abfd, r_type, h);
602 if (h != NULL)
603 riscv_elf_record_tls_type (abfd, h, r_symndx, GOT_TLS_LE);
604 goto static_reloc;
605
606 case R_RISCV_HI20:
607 if (bfd_link_pic (info))
608 return bad_static_reloc (abfd, r_type, h);
609 /* Fall through. */
610
611 case R_RISCV_COPY:
612 case R_RISCV_JUMP_SLOT:
613 case R_RISCV_RELATIVE:
614 case R_RISCV_64:
615 case R_RISCV_32:
616 /* Fall through. */
617
618 static_reloc:
619 /* This reloc might not bind locally. */
620 if (h != NULL)
621 h->non_got_ref = 1;
622
623 if (h != NULL && !bfd_link_pic (info))
624 {
625 /* We may need a .plt entry if the function this reloc
626 refers to is in a shared lib. */
627 h->plt.refcount += 1;
628 }
629
630 /* If we are creating a shared library, and this is a reloc
631 against a global symbol, or a non PC relative reloc
632 against a local symbol, then we need to copy the reloc
633 into the shared library. However, if we are linking with
634 -Bsymbolic, we do not need to copy a reloc against a
635 global symbol which is defined in an object we are
636 including in the link (i.e., DEF_REGULAR is set). At
637 this point we have not seen all the input files, so it is
638 possible that DEF_REGULAR is not set now but will be set
639 later (it is never cleared). In case of a weak definition,
640 DEF_REGULAR may be cleared later by a strong definition in
641 a shared library. We account for that possibility below by
642 storing information in the relocs_copied field of the hash
643 table entry. A similar situation occurs when creating
644 shared libraries and symbol visibility changes render the
645 symbol local.
646
647 If on the other hand, we are creating an executable, we
648 may need to keep relocations for symbols satisfied by a
649 dynamic library if we manage to avoid copy relocs for the
650 symbol. */
651 if ((bfd_link_pic (info)
652 && (sec->flags & SEC_ALLOC) != 0
653 && (! riscv_elf_rtype_to_howto (r_type)->pc_relative
654 || (h != NULL
655 && (! info->symbolic
656 || h->root.type == bfd_link_hash_defweak
657 || !h->def_regular))))
658 || (!bfd_link_pic (info)
659 && (sec->flags & SEC_ALLOC) != 0
660 && h != NULL
661 && (h->root.type == bfd_link_hash_defweak
662 || !h->def_regular)))
663 {
664 struct riscv_elf_dyn_relocs *p;
665 struct riscv_elf_dyn_relocs **head;
666
667 /* When creating a shared object, we must copy these
668 relocs into the output file. We create a reloc
669 section in dynobj and make room for the reloc. */
670 if (sreloc == NULL)
671 {
672 sreloc = _bfd_elf_make_dynamic_reloc_section
673 (sec, htab->elf.dynobj, RISCV_ELF_LOG_WORD_BYTES,
674 abfd, /*rela?*/ TRUE);
675
676 if (sreloc == NULL)
677 return FALSE;
678 }
679
680 /* If this is a global symbol, we count the number of
681 relocations we need for this symbol. */
682 if (h != NULL)
683 head = &((struct riscv_elf_link_hash_entry *) h)->dyn_relocs;
684 else
685 {
686 /* Track dynamic relocs needed for local syms too.
687 We really need local syms available to do this
688 easily. Oh well. */
689
690 asection *s;
691 void *vpp;
692 Elf_Internal_Sym *isym;
693
694 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
695 abfd, r_symndx);
696 if (isym == NULL)
697 return FALSE;
698
699 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
700 if (s == NULL)
701 s = sec;
702
703 vpp = &elf_section_data (s)->local_dynrel;
704 head = (struct riscv_elf_dyn_relocs **) vpp;
705 }
706
707 p = *head;
708 if (p == NULL || p->sec != sec)
709 {
710 bfd_size_type amt = sizeof *p;
711 p = ((struct riscv_elf_dyn_relocs *)
712 bfd_alloc (htab->elf.dynobj, amt));
713 if (p == NULL)
714 return FALSE;
715 p->next = *head;
716 *head = p;
717 p->sec = sec;
718 p->count = 0;
719 p->pc_count = 0;
720 }
721
722 p->count += 1;
723 p->pc_count += riscv_elf_rtype_to_howto (r_type)->pc_relative;
724 }
725
726 break;
727
728 case R_RISCV_GNU_VTINHERIT:
729 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
730 return FALSE;
731 break;
732
733 case R_RISCV_GNU_VTENTRY:
734 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
735 return FALSE;
736 break;
737
738 default:
739 break;
740 }
741 }
742
743 return TRUE;
744}
745
746static asection *
747riscv_elf_gc_mark_hook (asection *sec,
748 struct bfd_link_info *info,
749 Elf_Internal_Rela *rel,
750 struct elf_link_hash_entry *h,
751 Elf_Internal_Sym *sym)
752{
753 if (h != NULL)
754 switch (ELFNN_R_TYPE (rel->r_info))
755 {
756 case R_RISCV_GNU_VTINHERIT:
757 case R_RISCV_GNU_VTENTRY:
758 return NULL;
759 }
760
761 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
762}
763
e23eba97
NC		 764/* Adjust a symbol defined by a dynamic object and referenced by a
765 regular object. The current definition is in some section of the
766 dynamic object, but we're not including those sections. We have to
767 change the definition to something the rest of the link can
768 understand. */
769
770static bfd_boolean
771riscv_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
772 struct elf_link_hash_entry *h)
773{
774 struct riscv_elf_link_hash_table *htab;
775 struct riscv_elf_link_hash_entry * eh;
776 struct riscv_elf_dyn_relocs *p;
777 bfd *dynobj;
5474d94f 778 asection *s, *srel;
e23eba97
NC		 779
780 htab = riscv_elf_hash_table (info);
781 BFD_ASSERT (htab != NULL);
782
783 dynobj = htab->elf.dynobj;
784
785 /* Make sure we know what is going on here. */
786 BFD_ASSERT (dynobj != NULL
787 && (h->needs_plt
788 || h->type == STT_GNU_IFUNC
789 || h->u.weakdef != NULL
790 || (h->def_dynamic
791 && h->ref_regular
792 && !h->def_regular)));
793
794 /* If this is a function, put it in the procedure linkage table. We
795 will fill in the contents of the procedure linkage table later
796 (although we could actually do it here). */
797 if (h->type == STT_FUNC || h->type == STT_GNU_IFUNC || h->needs_plt)
798 {
799 if (h->plt.refcount <= 0
800 || SYMBOL_CALLS_LOCAL (info, h)
801 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
802 && h->root.type == bfd_link_hash_undefweak))
803 {
804 /* This case can occur if we saw a R_RISCV_CALL_PLT reloc in an
805 input file, but the symbol was never referred to by a dynamic
806 object, or if all references were garbage collected. In such
807 a case, we don't actually need to build a PLT entry. */
808 h->plt.offset = (bfd_vma) -1;
809 h->needs_plt = 0;
810 }
811
812 return TRUE;
813 }
814 else
815 h->plt.offset = (bfd_vma) -1;
816
817 /* If this is a weak symbol, and there is a real definition, the
818 processor independent code will have arranged for us to see the
819 real definition first, and we can just use the same value. */
820 if (h->u.weakdef != NULL)
821 {
822 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
823 || h->u.weakdef->root.type == bfd_link_hash_defweak);
824 h->root.u.def.section = h->u.weakdef->root.u.def.section;
825 h->root.u.def.value = h->u.weakdef->root.u.def.value;
826 return TRUE;
827 }
828
829 /* This is a reference to a symbol defined by a dynamic object which
830 is not a function. */
831
832 /* If we are creating a shared library, we must presume that the
833 only references to the symbol are via the global offset table.
834 For such cases we need not do anything here; the relocations will
835 be handled correctly by relocate_section. */
836 if (bfd_link_pic (info))
837 return TRUE;
838
839 /* If there are no references to this symbol that do not use the
840 GOT, we don't need to generate a copy reloc. */
841 if (!h->non_got_ref)
842 return TRUE;
843
844 /* If -z nocopyreloc was given, we won't generate them either. */
845 if (info->nocopyreloc)
846 {
847 h->non_got_ref = 0;
848 return TRUE;
849 }
850
851 eh = (struct riscv_elf_link_hash_entry *) h;
852 for (p = eh->dyn_relocs; p != NULL; p = p->next)
853 {
854 s = p->sec->output_section;
855 if (s != NULL && (s->flags & SEC_READONLY) != 0)
856 break;
857 }
858
859 /* If we didn't find any dynamic relocs in read-only sections, then
860 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
861 if (p == NULL)
862 {
863 h->non_got_ref = 0;
864 return TRUE;
865 }
866
867 /* We must allocate the symbol in our .dynbss section, which will
868 become part of the .bss section of the executable. There will be
869 an entry for this symbol in the .dynsym section. The dynamic
870 object will contain position independent code, so all references
871 from the dynamic object to this symbol will go through the global
872 offset table. The dynamic linker will use the .dynsym entry to
873 determine the address it must put in the global offset table, so
874 both the dynamic object and the regular object will refer to the
875 same memory location for the variable. */
876
877 /* We must generate a R_RISCV_COPY reloc to tell the dynamic linker
878 to copy the initial value out of the dynamic object and into the
879 runtime process image. We need to remember the offset into the
880 .rel.bss section we are going to use. */
3df5cd13
AW		 881 if (eh->tls_type & ~GOT_NORMAL)
882 {
883 s = htab->sdyntdata;
884 srel = htab->elf.srelbss;
885 }
886 else if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
5474d94f
AM		 887 {
888 s = htab->elf.sdynrelro;
889 srel = htab->elf.sreldynrelro;
890 }
891 else
892 {
893 s = htab->elf.sdynbss;
894 srel = htab->elf.srelbss;
895 }
e23eba97
NC		 896 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
897 {
5474d94f 898 srel->size += sizeof (ElfNN_External_Rela);
e23eba97
NC		 899 h->needs_copy = 1;
900 }
901
5474d94f 902 return _bfd_elf_adjust_dynamic_copy (info, h, s);
e23eba97
NC		 903}
904
905/* Allocate space in .plt, .got and associated reloc sections for
906 dynamic relocs. */
907
908static bfd_boolean
909allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
910{
911 struct bfd_link_info *info;
912 struct riscv_elf_link_hash_table *htab;
913 struct riscv_elf_link_hash_entry *eh;
914 struct riscv_elf_dyn_relocs *p;
915
916 if (h->root.type == bfd_link_hash_indirect)
917 return TRUE;
918
919 info = (struct bfd_link_info *) inf;
920 htab = riscv_elf_hash_table (info);
921 BFD_ASSERT (htab != NULL);
922
923 if (htab->elf.dynamic_sections_created
924 && h->plt.refcount > 0)
925 {
926 /* Make sure this symbol is output as a dynamic symbol.
927 Undefined weak syms won't yet be marked as dynamic. */
928 if (h->dynindx == -1
929 && !h->forced_local)
930 {
931 if (! bfd_elf_link_record_dynamic_symbol (info, h))
932 return FALSE;
933 }
934
935 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
936 {
937 asection *s = htab->elf.splt;
938
939 if (s->size == 0)
940 s->size = PLT_HEADER_SIZE;
941
942 h->plt.offset = s->size;
943
944 /* Make room for this entry. */
945 s->size += PLT_ENTRY_SIZE;
946
947 /* We also need to make an entry in the .got.plt section. */
948 htab->elf.sgotplt->size += GOT_ENTRY_SIZE;
949
950 /* We also need to make an entry in the .rela.plt section. */
951 htab->elf.srelplt->size += sizeof (ElfNN_External_Rela);
952
953 /* If this symbol is not defined in a regular file, and we are
954 not generating a shared library, then set the symbol to this
955 location in the .plt. This is required to make function
956 pointers compare as equal between the normal executable and
957 the shared library. */
958 if (! bfd_link_pic (info)
959 && !h->def_regular)
960 {
961 h->root.u.def.section = s;
962 h->root.u.def.value = h->plt.offset;
963 }
964 }
965 else
966 {
967 h->plt.offset = (bfd_vma) -1;
968 h->needs_plt = 0;
969 }
970 }
971 else
972 {
973 h->plt.offset = (bfd_vma) -1;
974 h->needs_plt = 0;
975 }
976
977 if (h->got.refcount > 0)
978 {
979 asection *s;
980 bfd_boolean dyn;
981 int tls_type = riscv_elf_hash_entry (h)->tls_type;
982
983 /* Make sure this symbol is output as a dynamic symbol.
984 Undefined weak syms won't yet be marked as dynamic. */
985 if (h->dynindx == -1
986 && !h->forced_local)
987 {
988 if (! bfd_elf_link_record_dynamic_symbol (info, h))
989 return FALSE;
990 }
991
992 s = htab->elf.sgot;
993 h->got.offset = s->size;
994 dyn = htab->elf.dynamic_sections_created;
995 if (tls_type & (GOT_TLS_GD | GOT_TLS_IE))
996 {
997 /* TLS_GD needs two dynamic relocs and two GOT slots. */
998 if (tls_type & GOT_TLS_GD)
999 {
1000 s->size += 2 * RISCV_ELF_WORD_BYTES;
1001 htab->elf.srelgot->size += 2 * sizeof (ElfNN_External_Rela);
1002 }
1003
1004 /* TLS_IE needs one dynamic reloc and one GOT slot. */
1005 if (tls_type & GOT_TLS_IE)
1006 {
1007 s->size += RISCV_ELF_WORD_BYTES;
1008 htab->elf.srelgot->size += sizeof (ElfNN_External_Rela);
1009 }
1010 }
1011 else
1012 {
1013 s->size += RISCV_ELF_WORD_BYTES;
1014 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h))
1015 htab->elf.srelgot->size += sizeof (ElfNN_External_Rela);
1016 }
1017 }
1018 else
1019 h->got.offset = (bfd_vma) -1;
1020
1021 eh = (struct riscv_elf_link_hash_entry *) h;
1022 if (eh->dyn_relocs == NULL)
1023 return TRUE;
1024
1025 /* In the shared -Bsymbolic case, discard space allocated for
1026 dynamic pc-relative relocs against symbols which turn out to be
1027 defined in regular objects. For the normal shared case, discard
1028 space for pc-relative relocs that have become local due to symbol
1029 visibility changes. */
1030
1031 if (bfd_link_pic (info))
1032 {
1033 if (SYMBOL_CALLS_LOCAL (info, h))
1034 {
1035 struct riscv_elf_dyn_relocs **pp;
1036
1037 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1038 {
1039 p->count -= p->pc_count;
1040 p->pc_count = 0;
1041 if (p->count == 0)
1042 *pp = p->next;
1043 else
1044 pp = &p->next;
1045 }
1046 }
1047
1048 /* Also discard relocs on undefined weak syms with non-default
1049 visibility. */
1050 if (eh->dyn_relocs != NULL
1051 && h->root.type == bfd_link_hash_undefweak)
1052 {
1053 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
1054 eh->dyn_relocs = NULL;
1055
1056 /* Make sure undefined weak symbols are output as a dynamic
1057 symbol in PIEs. */
1058 else if (h->dynindx == -1
1059 && !h->forced_local)
1060 {
1061 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1062 return FALSE;
1063 }
1064 }
1065 }
1066 else
1067 {
1068 /* For the non-shared case, discard space for relocs against
1069 symbols which turn out to need copy relocs or are not
1070 dynamic. */
1071
1072 if (!h->non_got_ref
1073 && ((h->def_dynamic
1074 && !h->def_regular)
1075 || (htab->elf.dynamic_sections_created
1076 && (h->root.type == bfd_link_hash_undefweak
1077 || h->root.type == bfd_link_hash_undefined))))
1078 {
1079 /* Make sure this symbol is output as a dynamic symbol.
1080 Undefined weak syms won't yet be marked as dynamic. */
1081 if (h->dynindx == -1
1082 && !h->forced_local)
1083 {
1084 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1085 return FALSE;
1086 }
1087
1088 /* If that succeeded, we know we'll be keeping all the
1089 relocs. */
1090 if (h->dynindx != -1)
1091 goto keep;
1092 }
1093
1094 eh->dyn_relocs = NULL;
1095
1096 keep: ;
1097 }
1098
1099 /* Finally, allocate space. */
1100 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1101 {
1102 asection *sreloc = elf_section_data (p->sec)->sreloc;
1103 sreloc->size += p->count * sizeof (ElfNN_External_Rela);
1104 }
1105
1106 return TRUE;
1107}
1108
1109/* Find any dynamic relocs that apply to read-only sections. */
1110
1111static bfd_boolean
1112readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
1113{
1114 struct riscv_elf_link_hash_entry *eh;
1115 struct riscv_elf_dyn_relocs *p;
1116
1117 eh = (struct riscv_elf_link_hash_entry *) h;
1118 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1119 {
1120 asection *s = p->sec->output_section;
1121
1122 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1123 {
1124 ((struct bfd_link_info *) inf)->flags |= DF_TEXTREL;
1125 return FALSE;
1126 }
1127 }
1128 return TRUE;
1129}
1130
1131static bfd_boolean
1132riscv_elf_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
1133{
1134 struct riscv_elf_link_hash_table *htab;
1135 bfd *dynobj;
1136 asection *s;
1137 bfd *ibfd;
1138
1139 htab = riscv_elf_hash_table (info);
1140 BFD_ASSERT (htab != NULL);
1141 dynobj = htab->elf.dynobj;
1142 BFD_ASSERT (dynobj != NULL);
1143
1144 if (elf_hash_table (info)->dynamic_sections_created)
1145 {
1146 /* Set the contents of the .interp section to the interpreter. */
1147 if (bfd_link_executable (info) && !info->nointerp)
1148 {
1149 s = bfd_get_linker_section (dynobj, ".interp");
1150 BFD_ASSERT (s != NULL);
1151 s->size = strlen (ELFNN_DYNAMIC_INTERPRETER) + 1;
1152 s->contents = (unsigned char *) ELFNN_DYNAMIC_INTERPRETER;
1153 }
1154 }
1155
1156 /* Set up .got offsets for local syms, and space for local dynamic
1157 relocs. */
1158 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
1159 {
1160 bfd_signed_vma *local_got;
1161 bfd_signed_vma *end_local_got;
1162 char *local_tls_type;
1163 bfd_size_type locsymcount;
1164 Elf_Internal_Shdr *symtab_hdr;
1165 asection *srel;
1166
1167 if (! is_riscv_elf (ibfd))
1168 continue;
1169
1170 for (s = ibfd->sections; s != NULL; s = s->next)
1171 {
1172 struct riscv_elf_dyn_relocs *p;
1173
1174 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
1175 {
1176 if (!bfd_is_abs_section (p->sec)
1177 && bfd_is_abs_section (p->sec->output_section))
1178 {
1179 /* Input section has been discarded, either because
1180 it is a copy of a linkonce section or due to
1181 linker script /DISCARD/, so we'll be discarding
1182 the relocs too. */
1183 }
1184 else if (p->count != 0)
1185 {
1186 srel = elf_section_data (p->sec)->sreloc;
1187 srel->size += p->count * sizeof (ElfNN_External_Rela);
1188 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
1189 info->flags |= DF_TEXTREL;
1190 }
1191 }
1192 }
1193
1194 local_got = elf_local_got_refcounts (ibfd);
1195 if (!local_got)
1196 continue;
1197
1198 symtab_hdr = &elf_symtab_hdr (ibfd);
1199 locsymcount = symtab_hdr->sh_info;
1200 end_local_got = local_got + locsymcount;
1201 local_tls_type = _bfd_riscv_elf_local_got_tls_type (ibfd);
1202 s = htab->elf.sgot;
1203 srel = htab->elf.srelgot;
1204 for (; local_got < end_local_got; ++local_got, ++local_tls_type)
1205 {
1206 if (*local_got > 0)
1207 {
1208 *local_got = s->size;
1209 s->size += RISCV_ELF_WORD_BYTES;
1210 if (*local_tls_type & GOT_TLS_GD)
1211 s->size += RISCV_ELF_WORD_BYTES;
1212 if (bfd_link_pic (info)
1213 || (*local_tls_type & (GOT_TLS_GD | GOT_TLS_IE)))
1214 srel->size += sizeof (ElfNN_External_Rela);
1215 }
1216 else
1217 *local_got = (bfd_vma) -1;
1218 }
1219 }
1220
1221 /* Allocate global sym .plt and .got entries, and space for global
1222 sym dynamic relocs. */
1223 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
1224
1225 if (htab->elf.sgotplt)
1226 {
1227 struct elf_link_hash_entry *got;
1228 got = elf_link_hash_lookup (elf_hash_table (info),
1229 "_GLOBAL_OFFSET_TABLE_",
1230 FALSE, FALSE, FALSE);
1231
1232 /* Don't allocate .got.plt section if there are no GOT nor PLT
1233 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
1234 if ((got == NULL
1235 || !got->ref_regular_nonweak)
1236 && (htab->elf.sgotplt->size == GOTPLT_HEADER_SIZE)
1237 && (htab->elf.splt == NULL
1238 || htab->elf.splt->size == 0)
1239 && (htab->elf.sgot == NULL
1240 || (htab->elf.sgot->size
1241 == get_elf_backend_data (output_bfd)->got_header_size)))
1242 htab->elf.sgotplt->size = 0;
1243 }
1244
1245 /* The check_relocs and adjust_dynamic_symbol entry points have
1246 determined the sizes of the various dynamic sections. Allocate
1247 memory for them. */
1248 for (s = dynobj->sections; s != NULL; s = s->next)
1249 {
1250 if ((s->flags & SEC_LINKER_CREATED) == 0)
1251 continue;
1252
1253 if (s == htab->elf.splt
1254 || s == htab->elf.sgot
1255 || s == htab->elf.sgotplt
5474d94f
AM		 1256 || s == htab->elf.sdynbss
1257 || s == htab->elf.sdynrelro)
e23eba97
NC		 1258 {
1259 /* Strip this section if we don't need it; see the
1260 comment below. */
1261 }
1262 else if (strncmp (s->name, ".rela", 5) == 0)
1263 {
1264 if (s->size != 0)
1265 {
1266 /* We use the reloc_count field as a counter if we need
1267 to copy relocs into the output file. */
1268 s->reloc_count = 0;
1269 }
1270 }
1271 else
1272 {
1273 /* It's not one of our sections. */
1274 continue;
1275 }
1276
1277 if (s->size == 0)
1278 {
1279 /* If we don't need this section, strip it from the
1280 output file. This is mostly to handle .rela.bss and
1281 .rela.plt. We must create both sections in
1282 create_dynamic_sections, because they must be created
1283 before the linker maps input sections to output
1284 sections. The linker does that before
1285 adjust_dynamic_symbol is called, and it is that
1286 function which decides whether anything needs to go
1287 into these sections. */
1288 s->flags |= SEC_EXCLUDE;
1289 continue;
1290 }
1291
1292 if ((s->flags & SEC_HAS_CONTENTS) == 0)
1293 continue;
1294
1295 /* Allocate memory for the section contents. Zero the memory
1296 for the benefit of .rela.plt, which has 4 unused entries
1297 at the beginning, and we don't want garbage. */
1298 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
1299 if (s->contents == NULL)
1300 return FALSE;
1301 }
1302
1303 if (elf_hash_table (info)->dynamic_sections_created)
1304 {
1305 /* Add some entries to the .dynamic section. We fill in the
1306 values later, in riscv_elf_finish_dynamic_sections, but we
1307 must add the entries now so that we get the correct size for
1308 the .dynamic section. The DT_DEBUG entry is filled in by the
1309 dynamic linker and used by the debugger. */
1310#define add_dynamic_entry(TAG, VAL) \
1311 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1312
1313 if (bfd_link_executable (info))
1314 {
1315 if (!add_dynamic_entry (DT_DEBUG, 0))
1316 return FALSE;
1317 }
1318
1319 if (htab->elf.srelplt->size != 0)
1320 {
1321 if (!add_dynamic_entry (DT_PLTGOT, 0)
1322 || !add_dynamic_entry (DT_PLTRELSZ, 0)
1323 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
1324 || !add_dynamic_entry (DT_JMPREL, 0))
1325 return FALSE;
1326 }
1327
1328 if (!add_dynamic_entry (DT_RELA, 0)
1329 || !add_dynamic_entry (DT_RELASZ, 0)
1330 || !add_dynamic_entry (DT_RELAENT, sizeof (ElfNN_External_Rela)))
1331 return FALSE;
1332
1333 /* If any dynamic relocs apply to a read-only section,
1334 then we need a DT_TEXTREL entry. */
1335 if ((info->flags & DF_TEXTREL) == 0)
1336 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, info);
1337
1338 if (info->flags & DF_TEXTREL)
1339 {
1340 if (!add_dynamic_entry (DT_TEXTREL, 0))
1341 return FALSE;
1342 }
1343 }
1344#undef add_dynamic_entry
1345
1346 return TRUE;
1347}
1348
1349#define TP_OFFSET 0
1350#define DTP_OFFSET 0x800
1351
1352/* Return the relocation value for a TLS dtp-relative reloc. */
1353
1354static bfd_vma
1355dtpoff (struct bfd_link_info *info, bfd_vma address)
1356{
1357 /* If tls_sec is NULL, we should have signalled an error already. */
1358 if (elf_hash_table (info)->tls_sec == NULL)
1359 return 0;
1360 return address - elf_hash_table (info)->tls_sec->vma - DTP_OFFSET;
1361}
1362
1363/* Return the relocation value for a static TLS tp-relative relocation. */
1364
1365static bfd_vma
1366tpoff (struct bfd_link_info *info, bfd_vma address)
1367{
1368 /* If tls_sec is NULL, we should have signalled an error already. */
1369 if (elf_hash_table (info)->tls_sec == NULL)
1370 return 0;
1371 return address - elf_hash_table (info)->tls_sec->vma - TP_OFFSET;
1372}
1373
1374/* Return the global pointer's value, or 0 if it is not in use. */
1375
1376static bfd_vma
1377riscv_global_pointer_value (struct bfd_link_info *info)
1378{
1379 struct bfd_link_hash_entry *h;
1380
b5292032 1381 h = bfd_link_hash_lookup (info->hash, RISCV_GP_SYMBOL, FALSE, FALSE, TRUE);
e23eba97
NC		 1382 if (h == NULL || h->type != bfd_link_hash_defined)
1383 return 0;
1384
1385 return h->u.def.value + sec_addr (h->u.def.section);
1386}
1387
1388/* Emplace a static relocation. */
1389
1390static bfd_reloc_status_type
1391perform_relocation (const reloc_howto_type *howto,
1392 const Elf_Internal_Rela *rel,
1393 bfd_vma value,
1394 asection *input_section,
1395 bfd *input_bfd,
1396 bfd_byte *contents)
1397{
1398 if (howto->pc_relative)
1399 value -= sec_addr (input_section) + rel->r_offset;
1400 value += rel->r_addend;
1401
1402 switch (ELFNN_R_TYPE (rel->r_info))
1403 {
1404 case R_RISCV_HI20:
1405 case R_RISCV_TPREL_HI20:
1406 case R_RISCV_PCREL_HI20:
1407 case R_RISCV_GOT_HI20:
1408 case R_RISCV_TLS_GOT_HI20:
1409 case R_RISCV_TLS_GD_HI20:
1410 if (ARCH_SIZE > 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (value)))
1411 return bfd_reloc_overflow;
1412 value = ENCODE_UTYPE_IMM (RISCV_CONST_HIGH_PART (value));
1413 break;
1414
1415 case R_RISCV_LO12_I:
1416 case R_RISCV_GPREL_I:
1417 case R_RISCV_TPREL_LO12_I:
45f76423 1418 case R_RISCV_TPREL_I:
e23eba97
NC		 1419 case R_RISCV_PCREL_LO12_I:
1420 value = ENCODE_ITYPE_IMM (value);
1421 break;
1422
1423 case R_RISCV_LO12_S:
1424 case R_RISCV_GPREL_S:
1425 case R_RISCV_TPREL_LO12_S:
45f76423 1426 case R_RISCV_TPREL_S:
e23eba97
NC		 1427 case R_RISCV_PCREL_LO12_S:
1428 value = ENCODE_STYPE_IMM (value);
1429 break;
1430
1431 case R_RISCV_CALL:
1432 case R_RISCV_CALL_PLT:
1433 if (ARCH_SIZE > 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (value)))
1434 return bfd_reloc_overflow;
1435 value = ENCODE_UTYPE_IMM (RISCV_CONST_HIGH_PART (value))
1436 | (ENCODE_ITYPE_IMM (value) << 32);
1437 break;
1438
1439 case R_RISCV_JAL:
1440 if (!VALID_UJTYPE_IMM (value))
1441 return bfd_reloc_overflow;
1442 value = ENCODE_UJTYPE_IMM (value);
1443 break;
1444
1445 case R_RISCV_BRANCH:
1446 if (!VALID_SBTYPE_IMM (value))
1447 return bfd_reloc_overflow;
1448 value = ENCODE_SBTYPE_IMM (value);
1449 break;
1450
1451 case R_RISCV_RVC_BRANCH:
1452 if (!VALID_RVC_B_IMM (value))
1453 return bfd_reloc_overflow;
1454 value = ENCODE_RVC_B_IMM (value);
1455 break;
1456
1457 case R_RISCV_RVC_JUMP:
1458 if (!VALID_RVC_J_IMM (value))
1459 return bfd_reloc_overflow;
1460 value = ENCODE_RVC_J_IMM (value);
1461 break;
1462
1463 case R_RISCV_RVC_LUI:
1464 if (!VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (value)))
1465 return bfd_reloc_overflow;
1466 value = ENCODE_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (value));
1467 break;
1468
1469 case R_RISCV_32:
1470 case R_RISCV_64:
1471 case R_RISCV_ADD8:
1472 case R_RISCV_ADD16:
1473 case R_RISCV_ADD32:
1474 case R_RISCV_ADD64:
45f76423 1475 case R_RISCV_SUB6:
e23eba97
NC		 1476 case R_RISCV_SUB8:
1477 case R_RISCV_SUB16:
1478 case R_RISCV_SUB32:
1479 case R_RISCV_SUB64:
45f76423
AW		 1480 case R_RISCV_SET6:
1481 case R_RISCV_SET8:
1482 case R_RISCV_SET16:
1483 case R_RISCV_SET32:
a6cbf936 1484 case R_RISCV_32_PCREL:
e23eba97
NC		 1485 case R_RISCV_TLS_DTPREL32:
1486 case R_RISCV_TLS_DTPREL64:
1487 break;
1488
ff6f4d9b
PD		 1489 case R_RISCV_DELETE:
1490 return bfd_reloc_ok;
1491
e23eba97
NC		 1492 default:
1493 return bfd_reloc_notsupported;
1494 }
1495
1496 bfd_vma word = bfd_get (howto->bitsize, input_bfd, contents + rel->r_offset);
1497 word = (word & ~howto->dst_mask) | (value & howto->dst_mask);
1498 bfd_put (howto->bitsize, input_bfd, word, contents + rel->r_offset);
1499
1500 return bfd_reloc_ok;
1501}
1502
1503/* Remember all PC-relative high-part relocs we've encountered to help us
1504 later resolve the corresponding low-part relocs. */
1505
1506typedef struct
1507{
1508 bfd_vma address;
1509 bfd_vma value;
1510} riscv_pcrel_hi_reloc;
1511
1512typedef struct riscv_pcrel_lo_reloc
1513{
1514 asection * input_section;
1515 struct bfd_link_info * info;
1516 reloc_howto_type * howto;
1517 const Elf_Internal_Rela * reloc;
1518 bfd_vma addr;
1519 const char * name;
1520 bfd_byte * contents;
1521 struct riscv_pcrel_lo_reloc * next;
1522} riscv_pcrel_lo_reloc;
1523
1524typedef struct
1525{
1526 htab_t hi_relocs;
1527 riscv_pcrel_lo_reloc *lo_relocs;
1528} riscv_pcrel_relocs;
1529
1530static hashval_t
1531riscv_pcrel_reloc_hash (const void *entry)
1532{
1533 const riscv_pcrel_hi_reloc *e = entry;
1534 return (hashval_t)(e->address >> 2);
1535}
1536
1537static bfd_boolean
1538riscv_pcrel_reloc_eq (const void *entry1, const void *entry2)
1539{
1540 const riscv_pcrel_hi_reloc *e1 = entry1, *e2 = entry2;
1541 return e1->address == e2->address;
1542}
1543
1544static bfd_boolean
1545riscv_init_pcrel_relocs (riscv_pcrel_relocs *p)
1546{
1547
1548 p->lo_relocs = NULL;
1549 p->hi_relocs = htab_create (1024, riscv_pcrel_reloc_hash,
1550 riscv_pcrel_reloc_eq, free);
1551 return p->hi_relocs != NULL;
1552}
1553
1554static void
1555riscv_free_pcrel_relocs (riscv_pcrel_relocs *p)
1556{
1557 riscv_pcrel_lo_reloc *cur = p->lo_relocs;
1558
1559 while (cur != NULL)
1560 {
1561 riscv_pcrel_lo_reloc *next = cur->next;
1562 free (cur);
1563 cur = next;
1564 }
1565
1566 htab_delete (p->hi_relocs);
1567}
1568
1569static bfd_boolean
b1308d2c
PD		 1570riscv_zero_pcrel_hi_reloc (Elf_Internal_Rela *rel,
1571 struct bfd_link_info *info,
1572 bfd_vma pc,
1573 bfd_vma addr,
1574 bfd_byte *contents,
1575 const reloc_howto_type *howto,
1576 bfd *input_bfd)
e23eba97 1577{
b1308d2c
PD		 1578 /* We may need to reference low addreses in PC-relative modes even when the
1579 * PC is far away from these addresses. For example, undefweak references
1580 * need to produce the address 0 when linked. As 0 is far from the arbitrary
1581 * addresses that we can link PC-relative programs at, the linker can't
1582 * actually relocate references to those symbols. In order to allow these
1583 * programs to work we simply convert the PC-relative auipc sequences to
1584 * 0-relative lui sequences. */
1585 if (bfd_link_pic (info))
1586 return FALSE;
1587
1588 /* If it's possible to reference the symbol using auipc we do so, as that's
1589 * more in the spirit of the PC-relative relocations we're processing. */
1590 bfd_vma offset = addr - pc;
1591 if (ARCH_SIZE == 32 || VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (offset)))
1592 return FALSE;
1593
1594 /* If it's impossible to reference this with a LUI-based offset then don't
1595 * bother to convert it at all so users still see the PC-relative relocation
1596 * in the truncation message. */
1597 if (ARCH_SIZE > 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (addr)))
1598 return FALSE;
1599
1600 rel->r_info = ELFNN_R_INFO(addr, R_RISCV_HI20);
1601
1602 bfd_vma insn = bfd_get(howto->bitsize, input_bfd, contents + rel->r_offset);
1603 insn = (insn & ~MASK_AUIPC) | MATCH_LUI;
1604 bfd_put(howto->bitsize, input_bfd, insn, contents + rel->r_offset);
1605 return TRUE;
1606}
1607
1608static bfd_boolean
1609riscv_record_pcrel_hi_reloc (riscv_pcrel_relocs *p, bfd_vma addr,
1610 bfd_vma value, bfd_boolean absolute)
1611{
1612 bfd_vma offset = absolute ? value : value - addr;
1613 riscv_pcrel_hi_reloc entry = {addr, offset};
e23eba97
NC		 1614 riscv_pcrel_hi_reloc **slot =
1615 (riscv_pcrel_hi_reloc **) htab_find_slot (p->hi_relocs, &entry, INSERT);
1616
1617 BFD_ASSERT (*slot == NULL);
1618 *slot = (riscv_pcrel_hi_reloc *) bfd_malloc (sizeof (riscv_pcrel_hi_reloc));
1619 if (*slot == NULL)
1620 return FALSE;
1621 **slot = entry;
1622 return TRUE;
1623}
1624
1625static bfd_boolean
1626riscv_record_pcrel_lo_reloc (riscv_pcrel_relocs *p,
1627 asection *input_section,
1628 struct bfd_link_info *info,
1629 reloc_howto_type *howto,
1630 const Elf_Internal_Rela *reloc,
1631 bfd_vma addr,
1632 const char *name,
1633 bfd_byte *contents)
1634{
1635 riscv_pcrel_lo_reloc *entry;
1636 entry = (riscv_pcrel_lo_reloc *) bfd_malloc (sizeof (riscv_pcrel_lo_reloc));
1637 if (entry == NULL)
1638 return FALSE;
1639 *entry = (riscv_pcrel_lo_reloc) {input_section, info, howto, reloc, addr,
1640 name, contents, p->lo_relocs};
1641 p->lo_relocs = entry;
1642 return TRUE;
1643}
1644
1645static bfd_boolean
1646riscv_resolve_pcrel_lo_relocs (riscv_pcrel_relocs *p)
1647{
1648 riscv_pcrel_lo_reloc *r;
1649
1650 for (r = p->lo_relocs; r != NULL; r = r->next)
1651 {
1652 bfd *input_bfd = r->input_section->owner;
1653
1654 riscv_pcrel_hi_reloc search = {r->addr, 0};
1655 riscv_pcrel_hi_reloc *entry = htab_find (p->hi_relocs, &search);
1656 if (entry == NULL)
1657 {
1658 ((*r->info->callbacks->reloc_overflow)
1659 (r->info, NULL, r->name, r->howto->name, (bfd_vma) 0,
1660 input_bfd, r->input_section, r->reloc->r_offset));
1661 return TRUE;
1662 }
1663
1664 perform_relocation (r->howto, r->reloc, entry->value, r->input_section,
1665 input_bfd, r->contents);
1666 }
1667
1668 return TRUE;
1669}
1670
1671/* Relocate a RISC-V ELF section.
1672
1673 The RELOCATE_SECTION function is called by the new ELF backend linker
1674 to handle the relocations for a section.
1675
1676 The relocs are always passed as Rela structures.
1677
1678 This function is responsible for adjusting the section contents as
1679 necessary, and (if generating a relocatable output file) adjusting
1680 the reloc addend as necessary.
1681
1682 This function does not have to worry about setting the reloc
1683 address or the reloc symbol index.
1684
1685 LOCAL_SYMS is a pointer to the swapped in local symbols.
1686
1687 LOCAL_SECTIONS is an array giving the section in the input file
1688 corresponding to the st_shndx field of each local symbol.
1689
1690 The global hash table entry for the global symbols can be found
1691 via elf_sym_hashes (input_bfd).
1692
1693 When generating relocatable output, this function must handle
1694 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
1695 going to be the section symbol corresponding to the output
1696 section, which means that the addend must be adjusted
1697 accordingly. */
1698
1699static bfd_boolean
1700riscv_elf_relocate_section (bfd *output_bfd,
1701 struct bfd_link_info *info,
1702 bfd *input_bfd,
1703 asection *input_section,
1704 bfd_byte *contents,
1705 Elf_Internal_Rela *relocs,
1706 Elf_Internal_Sym *local_syms,
1707 asection **local_sections)
1708{
1709 Elf_Internal_Rela *rel;
1710 Elf_Internal_Rela *relend;
1711 riscv_pcrel_relocs pcrel_relocs;
1712 bfd_boolean ret = FALSE;
1713 asection *sreloc = elf_section_data (input_section)->sreloc;
1714 struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info);
1715 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_bfd);
1716 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
1717 bfd_vma *local_got_offsets = elf_local_got_offsets (input_bfd);
b1308d2c 1718 bfd_boolean absolute;
e23eba97
NC		 1719
1720 if (!riscv_init_pcrel_relocs (&pcrel_relocs))
1721 return FALSE;
1722
1723 relend = relocs + input_section->reloc_count;
1724 for (rel = relocs; rel < relend; rel++)
1725 {
1726 unsigned long r_symndx;
1727 struct elf_link_hash_entry *h;
1728 Elf_Internal_Sym *sym;
1729 asection *sec;
1730 bfd_vma relocation;
1731 bfd_reloc_status_type r = bfd_reloc_ok;
1732 const char *name;
1733 bfd_vma off, ie_off;
1734 bfd_boolean unresolved_reloc, is_ie = FALSE;
1735 bfd_vma pc = sec_addr (input_section) + rel->r_offset;
1736 int r_type = ELFNN_R_TYPE (rel->r_info), tls_type;
1737 reloc_howto_type *howto = riscv_elf_rtype_to_howto (r_type);
1738 const char *msg = NULL;
1739
1740 if (r_type == R_RISCV_GNU_VTINHERIT || r_type == R_RISCV_GNU_VTENTRY)
1741 continue;
1742
1743 /* This is a final link. */
1744 r_symndx = ELFNN_R_SYM (rel->r_info);
1745 h = NULL;
1746 sym = NULL;
1747 sec = NULL;
1748 unresolved_reloc = FALSE;
1749 if (r_symndx < symtab_hdr->sh_info)
1750 {
1751 sym = local_syms + r_symndx;
1752 sec = local_sections[r_symndx];
1753 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1754 }
1755 else
1756 {
1757 bfd_boolean warned, ignored;
1758
1759 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1760 r_symndx, symtab_hdr, sym_hashes,
1761 h, sec, relocation,
1762 unresolved_reloc, warned, ignored);
1763 if (warned)
1764 {
1765 /* To avoid generating warning messages about truncated
1766 relocations, set the relocation's address to be the same as
1767 the start of this section. */
1768 if (input_section->output_section != NULL)
1769 relocation = input_section->output_section->vma;
1770 else
1771 relocation = 0;
1772 }
1773 }
1774
1775 if (sec != NULL && discarded_section (sec))
1776 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
1777 rel, 1, relend, howto, 0, contents);
1778
1779 if (bfd_link_relocatable (info))
1780 continue;
1781
1782 if (h != NULL)
1783 name = h->root.root.string;
1784 else
1785 {
1786 name = (bfd_elf_string_from_elf_section
1787 (input_bfd, symtab_hdr->sh_link, sym->st_name));
1788 if (name == NULL || *name == '\0')
1789 name = bfd_section_name (input_bfd, sec);
1790 }
1791
1792 switch (r_type)
1793 {
1794 case R_RISCV_NONE:
45f76423 1795 case R_RISCV_RELAX:
e23eba97
NC		 1796 case R_RISCV_TPREL_ADD:
1797 case R_RISCV_COPY:
1798 case R_RISCV_JUMP_SLOT:
1799 case R_RISCV_RELATIVE:
1800 /* These require nothing of us at all. */
1801 continue;
1802
1803 case R_RISCV_HI20:
1804 case R_RISCV_BRANCH:
1805 case R_RISCV_RVC_BRANCH:
1806 case R_RISCV_RVC_LUI:
1807 case R_RISCV_LO12_I:
1808 case R_RISCV_LO12_S:
45f76423
AW		 1809 case R_RISCV_SET6:
1810 case R_RISCV_SET8:
1811 case R_RISCV_SET16:
1812 case R_RISCV_SET32:
a6cbf936 1813 case R_RISCV_32_PCREL:
ff6f4d9b 1814 case R_RISCV_DELETE:
e23eba97
NC		 1815 /* These require no special handling beyond perform_relocation. */
1816 break;
1817
1818 case R_RISCV_GOT_HI20:
1819 if (h != NULL)
1820 {
1821 bfd_boolean dyn, pic;
1822
1823 off = h->got.offset;
1824 BFD_ASSERT (off != (bfd_vma) -1);
1825 dyn = elf_hash_table (info)->dynamic_sections_created;
1826 pic = bfd_link_pic (info);
1827
1828 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, pic, h)
1829 || (pic && SYMBOL_REFERENCES_LOCAL (info, h)))
1830 {
1831 /* This is actually a static link, or it is a
1832 -Bsymbolic link and the symbol is defined
1833 locally, or the symbol was forced to be local
1834 because of a version file. We must initialize
1835 this entry in the global offset table. Since the
1836 offset must always be a multiple of the word size,
1837 we use the least significant bit to record whether
1838 we have initialized it already.
1839
1840 When doing a dynamic link, we create a .rela.got
1841 relocation entry to initialize the value. This
1842 is done in the finish_dynamic_symbol routine. */
1843 if ((off & 1) != 0)
1844 off &= ~1;
1845 else
1846 {
1847 bfd_put_NN (output_bfd, relocation,
1848 htab->elf.sgot->contents + off);
1849 h->got.offset |= 1;
1850 }
1851 }
1852 else
1853 unresolved_reloc = FALSE;
1854 }
1855 else
1856 {
1857 BFD_ASSERT (local_got_offsets != NULL
1858 && local_got_offsets[r_symndx] != (bfd_vma) -1);
1859
1860 off = local_got_offsets[r_symndx];
1861
1862 /* The offset must always be a multiple of the word size.
1863 So, we can use the least significant bit to record
1864 whether we have already processed this entry. */
1865 if ((off & 1) != 0)
1866 off &= ~1;
1867 else
1868 {
1869 if (bfd_link_pic (info))
1870 {
1871 asection *s;
1872 Elf_Internal_Rela outrel;
1873
1874 /* We need to generate a R_RISCV_RELATIVE reloc
1875 for the dynamic linker. */
1876 s = htab->elf.srelgot;
1877 BFD_ASSERT (s != NULL);
1878
1879 outrel.r_offset = sec_addr (htab->elf.sgot) + off;
1880 outrel.r_info =
1881 ELFNN_R_INFO (0, R_RISCV_RELATIVE);
1882 outrel.r_addend = relocation;
1883 relocation = 0;
1884 riscv_elf_append_rela (output_bfd, s, &outrel);
1885 }
1886
1887 bfd_put_NN (output_bfd, relocation,
1888 htab->elf.sgot->contents + off);
1889 local_got_offsets[r_symndx] |= 1;
1890 }
1891 }
1892 relocation = sec_addr (htab->elf.sgot) + off;
b1308d2c
PD		 1893 absolute = riscv_zero_pcrel_hi_reloc (rel,
1894 info,
1895 pc,
1896 relocation,
1897 contents,
1898 howto,
1899 input_bfd);
1900 r_type = ELFNN_R_TYPE (rel->r_info);
1901 howto = riscv_elf_rtype_to_howto (r_type);
1902 if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs, pc,
1903 relocation, absolute))
e23eba97
NC		 1904 r = bfd_reloc_overflow;
1905 break;
1906
1907 case R_RISCV_ADD8:
1908 case R_RISCV_ADD16:
1909 case R_RISCV_ADD32:
1910 case R_RISCV_ADD64:
1911 {
1912 bfd_vma old_value = bfd_get (howto->bitsize, input_bfd,
1913 contents + rel->r_offset);
1914 relocation = old_value + relocation;
1915 }
1916 break;
1917
45f76423 1918 case R_RISCV_SUB6:
e23eba97
NC		 1919 case R_RISCV_SUB8:
1920 case R_RISCV_SUB16:
1921 case R_RISCV_SUB32:
1922 case R_RISCV_SUB64:
1923 {
1924 bfd_vma old_value = bfd_get (howto->bitsize, input_bfd,
1925 contents + rel->r_offset);
1926 relocation = old_value - relocation;
1927 }
1928 break;
1929
1930 case R_RISCV_CALL_PLT:
1931 case R_RISCV_CALL:
1932 case R_RISCV_JAL:
1933 case R_RISCV_RVC_JUMP:
1934 if (bfd_link_pic (info) && h != NULL && h->plt.offset != MINUS_ONE)
1935 {
1936 /* Refer to the PLT entry. */
1937 relocation = sec_addr (htab->elf.splt) + h->plt.offset;
1938 unresolved_reloc = FALSE;
1939 }
1940 break;
1941
1942 case R_RISCV_TPREL_HI20:
1943 relocation = tpoff (info, relocation);
1944 break;
1945
1946 case R_RISCV_TPREL_LO12_I:
1947 case R_RISCV_TPREL_LO12_S:
45f76423
AW		 1948 relocation = tpoff (info, relocation);
1949 break;
1950
1951 case R_RISCV_TPREL_I:
1952 case R_RISCV_TPREL_S:
e23eba97
NC		 1953 relocation = tpoff (info, relocation);
1954 if (VALID_ITYPE_IMM (relocation + rel->r_addend))
1955 {
1956 /* We can use tp as the base register. */
1957 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
1958 insn &= ~(OP_MASK_RS1 << OP_SH_RS1);
1959 insn |= X_TP << OP_SH_RS1;
1960 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
1961 }
45f76423
AW		 1962 else
1963 r = bfd_reloc_overflow;
e23eba97
NC		 1964 break;
1965
1966 case R_RISCV_GPREL_I:
1967 case R_RISCV_GPREL_S:
1968 {
1969 bfd_vma gp = riscv_global_pointer_value (info);
1970 bfd_boolean x0_base = VALID_ITYPE_IMM (relocation + rel->r_addend);
1971 if (x0_base || VALID_ITYPE_IMM (relocation + rel->r_addend - gp))
1972 {
1973 /* We can use x0 or gp as the base register. */
1974 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
1975 insn &= ~(OP_MASK_RS1 << OP_SH_RS1);
1976 if (!x0_base)
1977 {
1978 rel->r_addend -= gp;
1979 insn |= X_GP << OP_SH_RS1;
1980 }
1981 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
1982 }
1983 else
1984 r = bfd_reloc_overflow;
1985 break;
1986 }
1987
1988 case R_RISCV_PCREL_HI20:
b1308d2c
PD		 1989 absolute = riscv_zero_pcrel_hi_reloc (rel,
1990 info,
1991 pc,
1992 relocation,
1993 contents,
1994 howto,
1995 input_bfd);
1996 r_type = ELFNN_R_TYPE (rel->r_info);
1997 howto = riscv_elf_rtype_to_howto (r_type);
e23eba97 1998 if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs, pc,
b1308d2c
PD		 1999 relocation + rel->r_addend,
2000 absolute))
e23eba97
NC		 2001 r = bfd_reloc_overflow;
2002 break;
2003
2004 case R_RISCV_PCREL_LO12_I:
2005 case R_RISCV_PCREL_LO12_S:
2006 if (riscv_record_pcrel_lo_reloc (&pcrel_relocs, input_section, info,
2007 howto, rel, relocation, name,
2008 contents))
2009 continue;
2010 r = bfd_reloc_overflow;
2011 break;
2012
2013 case R_RISCV_TLS_DTPREL32:
2014 case R_RISCV_TLS_DTPREL64:
2015 relocation = dtpoff (info, relocation);
2016 break;
2017
2018 case R_RISCV_32:
2019 case R_RISCV_64:
2020 if ((input_section->flags & SEC_ALLOC) == 0)
2021 break;
2022
2023 if ((bfd_link_pic (info)
2024 && (h == NULL
2025 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2026 || h->root.type != bfd_link_hash_undefweak)
2027 && (! howto->pc_relative
2028 || !SYMBOL_CALLS_LOCAL (info, h)))
2029 || (!bfd_link_pic (info)
2030 && h != NULL
2031 && h->dynindx != -1
2032 && !h->non_got_ref
2033 && ((h->def_dynamic
2034 && !h->def_regular)
2035 || h->root.type == bfd_link_hash_undefweak
2036 || h->root.type == bfd_link_hash_undefined)))
2037 {
2038 Elf_Internal_Rela outrel;
2039 bfd_boolean skip_static_relocation, skip_dynamic_relocation;
2040
2041 /* When generating a shared object, these relocations
2042 are copied into the output file to be resolved at run
2043 time. */
2044
2045 outrel.r_offset =
2046 _bfd_elf_section_offset (output_bfd, info, input_section,
2047 rel->r_offset);
2048 skip_static_relocation = outrel.r_offset != (bfd_vma) -2;
2049 skip_dynamic_relocation = outrel.r_offset >= (bfd_vma) -2;
2050 outrel.r_offset += sec_addr (input_section);
2051
2052 if (skip_dynamic_relocation)
2053 memset (&outrel, 0, sizeof outrel);
2054 else if (h != NULL && h->dynindx != -1
2055 && !(bfd_link_pic (info)
2056 && SYMBOLIC_BIND (info, h)
2057 && h->def_regular))
2058 {
2059 outrel.r_info = ELFNN_R_INFO (h->dynindx, r_type);
2060 outrel.r_addend = rel->r_addend;
2061 }
2062 else
2063 {
2064 outrel.r_info = ELFNN_R_INFO (0, R_RISCV_RELATIVE);
2065 outrel.r_addend = relocation + rel->r_addend;
2066 }
2067
2068 riscv_elf_append_rela (output_bfd, sreloc, &outrel);
2069 if (skip_static_relocation)
2070 continue;
2071 }
2072 break;
2073
2074 case R_RISCV_TLS_GOT_HI20:
2075 is_ie = TRUE;
2076 /* Fall through. */
2077
2078 case R_RISCV_TLS_GD_HI20:
2079 if (h != NULL)
2080 {
2081 off = h->got.offset;
2082 h->got.offset |= 1;
2083 }
2084 else
2085 {
2086 off = local_got_offsets[r_symndx];
2087 local_got_offsets[r_symndx] |= 1;
2088 }
2089
2090 tls_type = _bfd_riscv_elf_tls_type (input_bfd, h, r_symndx);
2091 BFD_ASSERT (tls_type & (GOT_TLS_IE | GOT_TLS_GD));
2092 /* If this symbol is referenced by both GD and IE TLS, the IE
2093 reference's GOT slot follows the GD reference's slots. */
2094 ie_off = 0;
2095 if ((tls_type & GOT_TLS_GD) && (tls_type & GOT_TLS_IE))
2096 ie_off = 2 * GOT_ENTRY_SIZE;
2097
2098 if ((off & 1) != 0)
2099 off &= ~1;
2100 else
2101 {
2102 Elf_Internal_Rela outrel;
2103 int indx = 0;
2104 bfd_boolean need_relocs = FALSE;
2105
2106 if (htab->elf.srelgot == NULL)
2107 abort ();
2108
2109 if (h != NULL)
2110 {
2111 bfd_boolean dyn, pic;
2112 dyn = htab->elf.dynamic_sections_created;
2113 pic = bfd_link_pic (info);
2114
2115 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, pic, h)
2116 && (!pic || !SYMBOL_REFERENCES_LOCAL (info, h)))
2117 indx = h->dynindx;
2118 }
2119
2120 /* The GOT entries have not been initialized yet. Do it
2121 now, and emit any relocations. */
2122 if ((bfd_link_pic (info) || indx != 0)
2123 && (h == NULL
2124 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2125 || h->root.type != bfd_link_hash_undefweak))
2126 need_relocs = TRUE;
2127
2128 if (tls_type & GOT_TLS_GD)
2129 {
2130 if (need_relocs)
2131 {
2132 outrel.r_offset = sec_addr (htab->elf.sgot) + off;
2133 outrel.r_addend = 0;
2134 outrel.r_info = ELFNN_R_INFO (indx, R_RISCV_TLS_DTPMODNN);
2135 bfd_put_NN (output_bfd, 0,
2136 htab->elf.sgot->contents + off);
2137 riscv_elf_append_rela (output_bfd, htab->elf.srelgot, &outrel);
2138 if (indx == 0)
2139 {
2140 BFD_ASSERT (! unresolved_reloc);
2141 bfd_put_NN (output_bfd,
2142 dtpoff (info, relocation),
2143 (htab->elf.sgot->contents + off +
2144 RISCV_ELF_WORD_BYTES));
2145 }
2146 else
2147 {
2148 bfd_put_NN (output_bfd, 0,
2149 (htab->elf.sgot->contents + off +
2150 RISCV_ELF_WORD_BYTES));
2151 outrel.r_info = ELFNN_R_INFO (indx, R_RISCV_TLS_DTPRELNN);
2152 outrel.r_offset += RISCV_ELF_WORD_BYTES;
2153 riscv_elf_append_rela (output_bfd, htab->elf.srelgot, &outrel);
2154 }
2155 }
2156 else
2157 {
2158 /* If we are not emitting relocations for a
2159 general dynamic reference, then we must be in a
2160 static link or an executable link with the
2161 symbol binding locally. Mark it as belonging
2162 to module 1, the executable. */
2163 bfd_put_NN (output_bfd, 1,
2164 htab->elf.sgot->contents + off);
2165 bfd_put_NN (output_bfd,
2166 dtpoff (info, relocation),
2167 (htab->elf.sgot->contents + off +
2168 RISCV_ELF_WORD_BYTES));
2169 }
2170 }
2171
2172 if (tls_type & GOT_TLS_IE)
2173 {
2174 if (need_relocs)
2175 {
2176 bfd_put_NN (output_bfd, 0,
2177 htab->elf.sgot->contents + off + ie_off);
2178 outrel.r_offset = sec_addr (htab->elf.sgot)
2179 + off + ie_off;
2180 outrel.r_addend = 0;
2181 if (indx == 0)
2182 outrel.r_addend = tpoff (info, relocation);
2183 outrel.r_info = ELFNN_R_INFO (indx, R_RISCV_TLS_TPRELNN);
2184 riscv_elf_append_rela (output_bfd, htab->elf.srelgot, &outrel);
2185 }
2186 else
2187 {
2188 bfd_put_NN (output_bfd, tpoff (info, relocation),
2189 htab->elf.sgot->contents + off + ie_off);
2190 }
2191 }
2192 }
2193
2194 BFD_ASSERT (off < (bfd_vma) -2);
2195 relocation = sec_addr (htab->elf.sgot) + off + (is_ie ? ie_off : 0);
b1308d2c
PD		 2196 if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs, pc,
2197 relocation, FALSE))
e23eba97
NC		 2198 r = bfd_reloc_overflow;
2199 unresolved_reloc = FALSE;
2200 break;
2201
2202 default:
2203 r = bfd_reloc_notsupported;
2204 }
2205
2206 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2207 because such sections are not SEC_ALLOC and thus ld.so will
2208 not process them. */
2209 if (unresolved_reloc
2210 && !((input_section->flags & SEC_DEBUGGING) != 0
2211 && h->def_dynamic)
2212 && _bfd_elf_section_offset (output_bfd, info, input_section,
2213 rel->r_offset) != (bfd_vma) -1)
2214 {
2215 (*_bfd_error_handler)
d42c267e 2216 (_("%B(%A+%#Lx): unresolvable %s relocation against symbol `%s'"),
e23eba97
NC		 2217 input_bfd,
2218 input_section,
d42c267e 2219 rel->r_offset,
e23eba97
NC		 2220 howto->name,
2221 h->root.root.string);
2222 continue;
2223 }
2224
2225 if (r == bfd_reloc_ok)
2226 r = perform_relocation (howto, rel, relocation, input_section,
2227 input_bfd, contents);
2228
2229 switch (r)
2230 {
2231 case bfd_reloc_ok:
2232 continue;
2233
2234 case bfd_reloc_overflow:
2235 info->callbacks->reloc_overflow
2236 (info, (h ? &h->root : NULL), name, howto->name,
2237 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
2238 break;
2239
2240 case bfd_reloc_undefined:
2241 info->callbacks->undefined_symbol
2242 (info, name, input_bfd, input_section, rel->r_offset,
2243 TRUE);
2244 break;
2245
2246 case bfd_reloc_outofrange:
2247 msg = _("internal error: out of range error");
2248 break;
2249
2250 case bfd_reloc_notsupported:
2251 msg = _("internal error: unsupported relocation error");
2252 break;
2253
2254 case bfd_reloc_dangerous:
2255 msg = _("internal error: dangerous relocation");
2256 break;
2257
2258 default:
2259 msg = _("internal error: unknown error");
2260 break;
2261 }
2262
2263 if (msg)
2264 info->callbacks->warning
2265 (info, msg, name, input_bfd, input_section, rel->r_offset);
2266 goto out;
2267 }
2268
2269 ret = riscv_resolve_pcrel_lo_relocs (&pcrel_relocs);
2270out:
2271 riscv_free_pcrel_relocs (&pcrel_relocs);
2272 return ret;
2273}
2274
2275/* Finish up dynamic symbol handling. We set the contents of various
2276 dynamic sections here. */
2277
2278static bfd_boolean
2279riscv_elf_finish_dynamic_symbol (bfd *output_bfd,
2280 struct bfd_link_info *info,
2281 struct elf_link_hash_entry *h,
2282 Elf_Internal_Sym *sym)
2283{
2284 struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info);
2285 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
2286
2287 if (h->plt.offset != (bfd_vma) -1)
2288 {
2289 /* We've decided to create a PLT entry for this symbol. */
2290 bfd_byte *loc;
2291 bfd_vma i, header_address, plt_idx, got_address;
2292 uint32_t plt_entry[PLT_ENTRY_INSNS];
2293 Elf_Internal_Rela rela;
2294
2295 BFD_ASSERT (h->dynindx != -1);
2296
2297 /* Calculate the address of the PLT header. */
2298 header_address = sec_addr (htab->elf.splt);
2299
2300 /* Calculate the index of the entry. */
2301 plt_idx = (h->plt.offset - PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
2302
2303 /* Calculate the address of the .got.plt entry. */
2304 got_address = riscv_elf_got_plt_val (plt_idx, info);
2305
2306 /* Find out where the .plt entry should go. */
2307 loc = htab->elf.splt->contents + h->plt.offset;
2308
2309 /* Fill in the PLT entry itself. */
2310 riscv_make_plt_entry (got_address, header_address + h->plt.offset,
2311 plt_entry);
2312 for (i = 0; i < PLT_ENTRY_INSNS; i++)
2313 bfd_put_32 (output_bfd, plt_entry[i], loc + 4*i);
2314
2315 /* Fill in the initial value of the .got.plt entry. */
2316 loc = htab->elf.sgotplt->contents
2317 + (got_address - sec_addr (htab->elf.sgotplt));
2318 bfd_put_NN (output_bfd, sec_addr (htab->elf.splt), loc);
2319
2320 /* Fill in the entry in the .rela.plt section. */
2321 rela.r_offset = got_address;
2322 rela.r_addend = 0;
2323 rela.r_info = ELFNN_R_INFO (h->dynindx, R_RISCV_JUMP_SLOT);
2324
2325 loc = htab->elf.srelplt->contents + plt_idx * sizeof (ElfNN_External_Rela);
2326 bed->s->swap_reloca_out (output_bfd, &rela, loc);
2327
2328 if (!h->def_regular)
2329 {
2330 /* Mark the symbol as undefined, rather than as defined in
2331 the .plt section. Leave the value alone. */
2332 sym->st_shndx = SHN_UNDEF;
2333 /* If the symbol is weak, we do need to clear the value.
2334 Otherwise, the PLT entry would provide a definition for
2335 the symbol even if the symbol wasn't defined anywhere,
2336 and so the symbol would never be NULL. */
2337 if (!h->ref_regular_nonweak)
2338 sym->st_value = 0;
2339 }
2340 }
2341
2342 if (h->got.offset != (bfd_vma) -1
1d65abb5 2343 && !(riscv_elf_hash_entry (h)->tls_type & (GOT_TLS_GD | GOT_TLS_IE)))
e23eba97
NC		 2344 {
2345 asection *sgot;
2346 asection *srela;
2347 Elf_Internal_Rela rela;
2348
2349 /* This symbol has an entry in the GOT. Set it up. */
2350
2351 sgot = htab->elf.sgot;
2352 srela = htab->elf.srelgot;
2353 BFD_ASSERT (sgot != NULL && srela != NULL);
2354
2355 rela.r_offset = sec_addr (sgot) + (h->got.offset &~ (bfd_vma) 1);
2356
2357 /* If this is a -Bsymbolic link, and the symbol is defined
2358 locally, we just want to emit a RELATIVE reloc. Likewise if
2359 the symbol was forced to be local because of a version file.
2360 The entry in the global offset table will already have been
2361 initialized in the relocate_section function. */
2362 if (bfd_link_pic (info)
2363 && (info->symbolic || h->dynindx == -1)
2364 && h->def_regular)
2365 {
2366 asection *sec = h->root.u.def.section;
2367 rela.r_info = ELFNN_R_INFO (0, R_RISCV_RELATIVE);
2368 rela.r_addend = (h->root.u.def.value
2369 + sec->output_section->vma
2370 + sec->output_offset);
2371 }
2372 else
2373 {
2374 BFD_ASSERT (h->dynindx != -1);
2375 rela.r_info = ELFNN_R_INFO (h->dynindx, R_RISCV_NN);
2376 rela.r_addend = 0;
2377 }
2378
2379 bfd_put_NN (output_bfd, 0,
2380 sgot->contents + (h->got.offset & ~(bfd_vma) 1));
2381 riscv_elf_append_rela (output_bfd, srela, &rela);
2382 }
2383
2384 if (h->needs_copy)
2385 {
2386 Elf_Internal_Rela rela;
5474d94f 2387 asection *s;
e23eba97
NC		 2388
2389 /* This symbols needs a copy reloc. Set it up. */
2390 BFD_ASSERT (h->dynindx != -1);
2391
2392 rela.r_offset = sec_addr (h->root.u.def.section) + h->root.u.def.value;
2393 rela.r_info = ELFNN_R_INFO (h->dynindx, R_RISCV_COPY);
2394 rela.r_addend = 0;
afbf7e8e 2395 if (h->root.u.def.section == htab->elf.sdynrelro)
5474d94f
AM		 2396 s = htab->elf.sreldynrelro;
2397 else
2398 s = htab->elf.srelbss;
2399 riscv_elf_append_rela (output_bfd, s, &rela);
e23eba97
NC		 2400 }
2401
2402 /* Mark some specially defined symbols as absolute. */
2403 if (h == htab->elf.hdynamic
2404 || (h == htab->elf.hgot || h == htab->elf.hplt))
2405 sym->st_shndx = SHN_ABS;
2406
2407 return TRUE;
2408}
2409
2410/* Finish up the dynamic sections. */
2411
2412static bfd_boolean
2413riscv_finish_dyn (bfd *output_bfd, struct bfd_link_info *info,
2414 bfd *dynobj, asection *sdyn)
2415{
2416 struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info);
2417 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
2418 size_t dynsize = bed->s->sizeof_dyn;
2419 bfd_byte *dyncon, *dynconend;
2420
2421 dynconend = sdyn->contents + sdyn->size;
2422 for (dyncon = sdyn->contents; dyncon < dynconend; dyncon += dynsize)
2423 {
2424 Elf_Internal_Dyn dyn;
2425 asection *s;
2426
2427 bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
2428
2429 switch (dyn.d_tag)
2430 {
2431 case DT_PLTGOT:
2432 s = htab->elf.sgotplt;
2433 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
2434 break;
2435 case DT_JMPREL:
2436 s = htab->elf.srelplt;
2437 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
2438 break;
2439 case DT_PLTRELSZ:
2440 s = htab->elf.srelplt;
2441 dyn.d_un.d_val = s->size;
2442 break;
2443 default:
2444 continue;
2445 }
2446
2447 bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
2448 }
2449 return TRUE;
2450}
2451
2452static bfd_boolean
2453riscv_elf_finish_dynamic_sections (bfd *output_bfd,
2454 struct bfd_link_info *info)
2455{
2456 bfd *dynobj;
2457 asection *sdyn;
2458 struct riscv_elf_link_hash_table *htab;
2459
2460 htab = riscv_elf_hash_table (info);
2461 BFD_ASSERT (htab != NULL);
2462 dynobj = htab->elf.dynobj;
2463
2464 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
2465
2466 if (elf_hash_table (info)->dynamic_sections_created)
2467 {
2468 asection *splt;
2469 bfd_boolean ret;
2470
2471 splt = htab->elf.splt;
2472 BFD_ASSERT (splt != NULL && sdyn != NULL);
2473
2474 ret = riscv_finish_dyn (output_bfd, info, dynobj, sdyn);
2475
535b785f 2476 if (!ret)
e23eba97
NC		 2477 return ret;
2478
2479 /* Fill in the head and tail entries in the procedure linkage table. */
2480 if (splt->size > 0)
2481 {
2482 int i;
2483 uint32_t plt_header[PLT_HEADER_INSNS];
2484 riscv_make_plt_header (sec_addr (htab->elf.sgotplt),
2485 sec_addr (splt), plt_header);
2486
2487 for (i = 0; i < PLT_HEADER_INSNS; i++)
2488 bfd_put_32 (output_bfd, plt_header[i], splt->contents + 4*i);
e23eba97 2489
cc162427
AW		 2490 elf_section_data (splt->output_section)->this_hdr.sh_entsize
2491 = PLT_ENTRY_SIZE;
2492 }
e23eba97
NC		 2493 }
2494
2495 if (htab->elf.sgotplt)
2496 {
2497 asection *output_section = htab->elf.sgotplt->output_section;
2498
2499 if (bfd_is_abs_section (output_section))
2500 {
2501 (*_bfd_error_handler)
2502 (_("discarded output section: `%A'"), htab->elf.sgotplt);
2503 return FALSE;
2504 }
2505
2506 if (htab->elf.sgotplt->size > 0)
2507 {
2508 /* Write the first two entries in .got.plt, needed for the dynamic
2509 linker. */
2510 bfd_put_NN (output_bfd, (bfd_vma) -1, htab->elf.sgotplt->contents);
2511 bfd_put_NN (output_bfd, (bfd_vma) 0,
2512 htab->elf.sgotplt->contents + GOT_ENTRY_SIZE);
2513 }
2514
2515 elf_section_data (output_section)->this_hdr.sh_entsize = GOT_ENTRY_SIZE;
2516 }
2517
2518 if (htab->elf.sgot)
2519 {
2520 asection *output_section = htab->elf.sgot->output_section;
2521
2522 if (htab->elf.sgot->size > 0)
2523 {
2524 /* Set the first entry in the global offset table to the address of
2525 the dynamic section. */
2526 bfd_vma val = sdyn ? sec_addr (sdyn) : 0;
2527 bfd_put_NN (output_bfd, val, htab->elf.sgot->contents);
2528 }
2529
2530 elf_section_data (output_section)->this_hdr.sh_entsize = GOT_ENTRY_SIZE;
2531 }
2532
2533 return TRUE;
2534}
2535
2536/* Return address for Ith PLT stub in section PLT, for relocation REL
2537 or (bfd_vma) -1 if it should not be included. */
2538
2539static bfd_vma
2540riscv_elf_plt_sym_val (bfd_vma i, const asection *plt,
2541 const arelent *rel ATTRIBUTE_UNUSED)
2542{
2543 return plt->vma + PLT_HEADER_SIZE + i * PLT_ENTRY_SIZE;
2544}
2545
2546static enum elf_reloc_type_class
2547riscv_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
2548 const asection *rel_sec ATTRIBUTE_UNUSED,
2549 const Elf_Internal_Rela *rela)
2550{
2551 switch (ELFNN_R_TYPE (rela->r_info))
2552 {
2553 case R_RISCV_RELATIVE:
2554 return reloc_class_relative;
2555 case R_RISCV_JUMP_SLOT:
2556 return reloc_class_plt;
2557 case R_RISCV_COPY:
2558 return reloc_class_copy;
2559 default:
2560 return reloc_class_normal;
2561 }
2562}
2563
2564/* Merge backend specific data from an object file to the output
2565 object file when linking. */
2566
2567static bfd_boolean
2568_bfd_riscv_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
2569{
2570 bfd *obfd = info->output_bfd;
2571 flagword new_flags = elf_elfheader (ibfd)->e_flags;
2572 flagword old_flags = elf_elfheader (obfd)->e_flags;
2573
2574 if (!is_riscv_elf (ibfd) || !is_riscv_elf (obfd))
2575 return TRUE;
2576
2577 if (strcmp (bfd_get_target (ibfd), bfd_get_target (obfd)) != 0)
2578 {
2579 (*_bfd_error_handler)
96b0927d
PD		 2580 (_("%B: ABI is incompatible with that of the selected emulation:\n"
2581 " target emulation `%s' does not match `%s'"),
2582 ibfd, bfd_get_target (ibfd), bfd_get_target (obfd));
e23eba97
NC		 2583 return FALSE;
2584 }
2585
2586 if (!_bfd_elf_merge_object_attributes (ibfd, info))
2587 return FALSE;
2588
2589 if (! elf_flags_init (obfd))
2590 {
2591 elf_flags_init (obfd) = TRUE;
2592 elf_elfheader (obfd)->e_flags = new_flags;
2593 return TRUE;
2594 }
2595
2922d21d
AW		 2596 /* Disallow linking different float ABIs. */
2597 if ((old_flags ^ new_flags) & EF_RISCV_FLOAT_ABI)
e23eba97
NC		 2598 {
2599 (*_bfd_error_handler)
2600 (_("%B: can't link hard-float modules with soft-float modules"), ibfd);
2601 goto fail;
2602 }
2603
2604 /* Allow linking RVC and non-RVC, and keep the RVC flag. */
2605 elf_elfheader (obfd)->e_flags |= new_flags & EF_RISCV_RVC;
2606
2607 return TRUE;
2608
2609fail:
2610 bfd_set_error (bfd_error_bad_value);
2611 return FALSE;
2612}
2613
2614/* Delete some bytes from a section while relaxing. */
2615
2616static bfd_boolean
2617riscv_relax_delete_bytes (bfd *abfd, asection *sec, bfd_vma addr, size_t count)
2618{
2619 unsigned int i, symcount;
2620 bfd_vma toaddr = sec->size;
2621 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (abfd);
2622 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2623 unsigned int sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
2624 struct bfd_elf_section_data *data = elf_section_data (sec);
2625 bfd_byte *contents = data->this_hdr.contents;
2626
2627 /* Actually delete the bytes. */
2628 sec->size -= count;
2629 memmove (contents + addr, contents + addr + count, toaddr - addr - count);
2630
2631 /* Adjust the location of all of the relocs. Note that we need not
2632 adjust the addends, since all PC-relative references must be against
2633 symbols, which we will adjust below. */
2634 for (i = 0; i < sec->reloc_count; i++)
2635 if (data->relocs[i].r_offset > addr && data->relocs[i].r_offset < toaddr)
2636 data->relocs[i].r_offset -= count;
2637
2638 /* Adjust the local symbols defined in this section. */
2639 for (i = 0; i < symtab_hdr->sh_info; i++)
2640 {
2641 Elf_Internal_Sym *sym = (Elf_Internal_Sym *) symtab_hdr->contents + i;
2642 if (sym->st_shndx == sec_shndx)
2643 {
2644 /* If the symbol is in the range of memory we just moved, we
2645 have to adjust its value. */
2646 if (sym->st_value > addr && sym->st_value <= toaddr)
2647 sym->st_value -= count;
2648
2649 /* If the symbol *spans* the bytes we just deleted (i.e. its
2650 *end* is in the moved bytes but its *start* isn't), then we
2651 must adjust its size. */
2652 if (sym->st_value <= addr
2653 && sym->st_value + sym->st_size > addr
2654 && sym->st_value + sym->st_size <= toaddr)
2655 sym->st_size -= count;
2656 }
2657 }
2658
2659 /* Now adjust the global symbols defined in this section. */
2660 symcount = ((symtab_hdr->sh_size / sizeof (ElfNN_External_Sym))
2661 - symtab_hdr->sh_info);
2662
2663 for (i = 0; i < symcount; i++)
2664 {
2665 struct elf_link_hash_entry *sym_hash = sym_hashes[i];
2666
2667 if ((sym_hash->root.type == bfd_link_hash_defined
2668 || sym_hash->root.type == bfd_link_hash_defweak)
2669 && sym_hash->root.u.def.section == sec)
2670 {
2671 /* As above, adjust the value if needed. */
2672 if (sym_hash->root.u.def.value > addr
2673 && sym_hash->root.u.def.value <= toaddr)
2674 sym_hash->root.u.def.value -= count;
2675
2676 /* As above, adjust the size if needed. */
2677 if (sym_hash->root.u.def.value <= addr
2678 && sym_hash->root.u.def.value + sym_hash->size > addr
2679 && sym_hash->root.u.def.value + sym_hash->size <= toaddr)
2680 sym_hash->size -= count;
2681 }
2682 }
2683
2684 return TRUE;
2685}
2686
45f76423
AW		 2687typedef bfd_boolean (*relax_func_t) (bfd *, asection *, asection *,
2688 struct bfd_link_info *,
2689 Elf_Internal_Rela *,
2690 bfd_vma, bfd_vma, bfd_vma, bfd_boolean *);
2691
e23eba97
NC		 2692/* Relax AUIPC + JALR into JAL. */
2693
2694static bfd_boolean
2695_bfd_riscv_relax_call (bfd *abfd, asection *sec, asection *sym_sec,
2696 struct bfd_link_info *link_info,
2697 Elf_Internal_Rela *rel,
2698 bfd_vma symval,
45f76423
AW		 2699 bfd_vma max_alignment,
2700 bfd_vma reserve_size ATTRIBUTE_UNUSED,
e23eba97
NC		 2701 bfd_boolean *again)
2702{
2703 bfd_byte *contents = elf_section_data (sec)->this_hdr.contents;
2704 bfd_signed_vma foff = symval - (sec_addr (sec) + rel->r_offset);
2705 bfd_boolean near_zero = (symval + RISCV_IMM_REACH/2) < RISCV_IMM_REACH;
2706 bfd_vma auipc, jalr;
2707 int rd, r_type, len = 4, rvc = elf_elfheader (abfd)->e_flags & EF_RISCV_RVC;
2708
2709 /* If the call crosses section boundaries, an alignment directive could
2710 cause the PC-relative offset to later increase. */
2711 if (VALID_UJTYPE_IMM (foff) && sym_sec->output_section != sec->output_section)
2712 foff += (foff < 0 ? -max_alignment : max_alignment);
2713
2714 /* See if this function call can be shortened. */
2715 if (!VALID_UJTYPE_IMM (foff) && !(!bfd_link_pic (link_info) && near_zero))
2716 return TRUE;
2717
2718 /* Shorten the function call. */
2719 BFD_ASSERT (rel->r_offset + 8 <= sec->size);
2720
2721 auipc = bfd_get_32 (abfd, contents + rel->r_offset);
2722 jalr = bfd_get_32 (abfd, contents + rel->r_offset + 4);
2723 rd = (jalr >> OP_SH_RD) & OP_MASK_RD;
2724 rvc = rvc && VALID_RVC_J_IMM (foff) && ARCH_SIZE == 32;
2725
2726 if (rvc && (rd == 0 || rd == X_RA))
2727 {
2728 /* Relax to C.J[AL] rd, addr. */
2729 r_type = R_RISCV_RVC_JUMP;
2730 auipc = rd == 0 ? MATCH_C_J : MATCH_C_JAL;
2731 len = 2;
2732 }
2733 else if (VALID_UJTYPE_IMM (foff))
2734 {
2735 /* Relax to JAL rd, addr. */
2736 r_type = R_RISCV_JAL;
2737 auipc = MATCH_JAL | (rd << OP_SH_RD);
2738 }
2739 else /* near_zero */
2740 {
2741 /* Relax to JALR rd, x0, addr. */
2742 r_type = R_RISCV_LO12_I;
2743 auipc = MATCH_JALR | (rd << OP_SH_RD);
2744 }
2745
2746 /* Replace the R_RISCV_CALL reloc. */
2747 rel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info), r_type);
2748 /* Replace the AUIPC. */
2749 bfd_put (8 * len, abfd, auipc, contents + rel->r_offset);
2750
2751 /* Delete unnecessary JALR. */
2752 *again = TRUE;
2753 return riscv_relax_delete_bytes (abfd, sec, rel->r_offset + len, 8 - len);
2754}
2755
2756/* Traverse all output sections and return the max alignment. */
2757
1d61f794 2758static bfd_vma
e23eba97
NC		 2759_bfd_riscv_get_max_alignment (asection *sec)
2760{
2761 unsigned int max_alignment_power = 0;
2762 asection *o;
2763
2764 for (o = sec->output_section->owner->sections; o != NULL; o = o->next)
2765 {
2766 if (o->alignment_power > max_alignment_power)
2767 max_alignment_power = o->alignment_power;
2768 }
2769
1d61f794 2770 return (bfd_vma) 1 << max_alignment_power;
e23eba97
NC		 2771}
2772
2773/* Relax non-PIC global variable references. */
2774
2775static bfd_boolean
2776_bfd_riscv_relax_lui (bfd *abfd,
2777 asection *sec,
2778 asection *sym_sec,
2779 struct bfd_link_info *link_info,
2780 Elf_Internal_Rela *rel,
2781 bfd_vma symval,
45f76423
AW		 2782 bfd_vma max_alignment,
2783 bfd_vma reserve_size,
e23eba97
NC		 2784 bfd_boolean *again)
2785{
2786 bfd_byte *contents = elf_section_data (sec)->this_hdr.contents;
2787 bfd_vma gp = riscv_global_pointer_value (link_info);
2788 int use_rvc = elf_elfheader (abfd)->e_flags & EF_RISCV_RVC;
2789
2790 /* Mergeable symbols and code might later move out of range. */
2791 if (sym_sec->flags & (SEC_MERGE | SEC_CODE))
2792 return TRUE;
2793
2794 BFD_ASSERT (rel->r_offset + 4 <= sec->size);
2795
d0f744f9
AW		 2796 if (gp)
2797 {
2798 /* If gp and the symbol are in the same output section, then
2799 consider only that section's alignment. */
2800 struct bfd_link_hash_entry *h =
b5292032
PD		 2801 bfd_link_hash_lookup (link_info->hash, RISCV_GP_SYMBOL, FALSE, FALSE,
2802 TRUE);
d0f744f9
AW		 2803 if (h->u.def.section->output_section == sym_sec->output_section)
2804 max_alignment = (bfd_vma) 1 << sym_sec->output_section->alignment_power;
2805 }
2806
e23eba97
NC		 2807 /* Is the reference in range of x0 or gp?
2808 Valid gp range conservatively because of alignment issue. */
2809 if (VALID_ITYPE_IMM (symval)
45f76423
AW		 2810 || (symval >= gp
2811 && VALID_ITYPE_IMM (symval - gp + max_alignment + reserve_size))
2812 || (symval < gp
2813 && VALID_ITYPE_IMM (symval - gp - max_alignment - reserve_size)))
e23eba97
NC		 2814 {
2815 unsigned sym = ELFNN_R_SYM (rel->r_info);
2816 switch (ELFNN_R_TYPE (rel->r_info))
2817 {
2818 case R_RISCV_LO12_I:
2819 rel->r_info = ELFNN_R_INFO (sym, R_RISCV_GPREL_I);
2820 return TRUE;
2821
2822 case R_RISCV_LO12_S:
2823 rel->r_info = ELFNN_R_INFO (sym, R_RISCV_GPREL_S);
2824 return TRUE;
2825
2826 case R_RISCV_HI20:
2827 /* We can delete the unnecessary LUI and reloc. */
2828 rel->r_info = ELFNN_R_INFO (0, R_RISCV_NONE);
2829 *again = TRUE;
2830 return riscv_relax_delete_bytes (abfd, sec, rel->r_offset, 4);
2831
2832 default:
2833 abort ();
2834 }
2835 }
2836
2837 /* Can we relax LUI to C.LUI? Alignment might move the section forward;
2838 account for this assuming page alignment at worst. */
2839 if (use_rvc
2840 && ELFNN_R_TYPE (rel->r_info) == R_RISCV_HI20
2841 && VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (symval))
2842 && VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (symval + ELF_MAXPAGESIZE)))
2843 {
2844 /* Replace LUI with C.LUI if legal (i.e., rd != x2/sp). */
2845 bfd_vma lui = bfd_get_32 (abfd, contents + rel->r_offset);
2846 if (((lui >> OP_SH_RD) & OP_MASK_RD) == X_SP)
2847 return TRUE;
2848
2849 lui = (lui & (OP_MASK_RD << OP_SH_RD)) | MATCH_C_LUI;
2850 bfd_put_32 (abfd, lui, contents + rel->r_offset);
2851
2852 /* Replace the R_RISCV_HI20 reloc. */
2853 rel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info), R_RISCV_RVC_LUI);
2854
2855 *again = TRUE;
2856 return riscv_relax_delete_bytes (abfd, sec, rel->r_offset + 2, 2);
2857 }
2858
2859 return TRUE;
2860}
2861
2862/* Relax non-PIC TLS references. */
2863
2864static bfd_boolean
2865_bfd_riscv_relax_tls_le (bfd *abfd,
2866 asection *sec,
2867 asection *sym_sec ATTRIBUTE_UNUSED,
2868 struct bfd_link_info *link_info,
2869 Elf_Internal_Rela *rel,
2870 bfd_vma symval,
45f76423
AW		 2871 bfd_vma max_alignment ATTRIBUTE_UNUSED,
2872 bfd_vma reserve_size ATTRIBUTE_UNUSED,
e23eba97
NC		 2873 bfd_boolean *again)
2874{
2875 /* See if this symbol is in range of tp. */
2876 if (RISCV_CONST_HIGH_PART (tpoff (link_info, symval)) != 0)
2877 return TRUE;
2878
e23eba97 2879 BFD_ASSERT (rel->r_offset + 4 <= sec->size);
45f76423
AW		 2880 switch (ELFNN_R_TYPE (rel->r_info))
2881 {
2882 case R_RISCV_TPREL_LO12_I:
2883 rel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info), R_RISCV_TPREL_I);
2884 return TRUE;
e23eba97 2885
45f76423
AW		 2886 case R_RISCV_TPREL_LO12_S:
2887 rel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info), R_RISCV_TPREL_S);
2888 return TRUE;
2889
2890 case R_RISCV_TPREL_HI20:
2891 case R_RISCV_TPREL_ADD:
2892 /* We can delete the unnecessary instruction and reloc. */
2893 rel->r_info = ELFNN_R_INFO (0, R_RISCV_NONE);
2894 *again = TRUE;
2895 return riscv_relax_delete_bytes (abfd, sec, rel->r_offset, 4);
2896
2897 default:
2898 abort ();
2899 }
e23eba97
NC		 2900}
2901
2902/* Implement R_RISCV_ALIGN by deleting excess alignment NOPs. */
2903
2904static bfd_boolean
2905_bfd_riscv_relax_align (bfd *abfd, asection *sec,
9eb7b0ac 2906 asection *sym_sec,
e23eba97
NC		 2907 struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
2908 Elf_Internal_Rela *rel,
2909 bfd_vma symval,
45f76423
AW		 2910 bfd_vma max_alignment ATTRIBUTE_UNUSED,
2911 bfd_vma reserve_size ATTRIBUTE_UNUSED,
e23eba97
NC		 2912 bfd_boolean *again ATTRIBUTE_UNUSED)
2913{
2914 bfd_byte *contents = elf_section_data (sec)->this_hdr.contents;
2915 bfd_vma alignment = 1, pos;
2916 while (alignment <= rel->r_addend)
2917 alignment *= 2;
2918
2919 symval -= rel->r_addend;
2920 bfd_vma aligned_addr = ((symval - 1) & ~(alignment - 1)) + alignment;
2921 bfd_vma nop_bytes = aligned_addr - symval;
2922
2923 /* Once we've handled an R_RISCV_ALIGN, we can't relax anything else. */
2924 sec->sec_flg0 = TRUE;
2925
2926 /* Make sure there are enough NOPs to actually achieve the alignment. */
2927 if (rel->r_addend < nop_bytes)
9eb7b0ac
PD		 2928 {
2929 (*_bfd_error_handler)
2930 (_("%B(%A+0x%lx): %d bytes required for alignment"
2931 "to %d-byte boundary, but only %d present"),
2932 abfd, sym_sec, rel->r_offset, nop_bytes, alignment, rel->r_addend);
2933 bfd_set_error (bfd_error_bad_value);
2934 return FALSE;
2935 }
e23eba97
NC		 2936
2937 /* Delete the reloc. */
2938 rel->r_info = ELFNN_R_INFO (0, R_RISCV_NONE);
2939
2940 /* If the number of NOPs is already correct, there's nothing to do. */
2941 if (nop_bytes == rel->r_addend)
2942 return TRUE;
2943
2944 /* Write as many RISC-V NOPs as we need. */
2945 for (pos = 0; pos < (nop_bytes & -4); pos += 4)
2946 bfd_put_32 (abfd, RISCV_NOP, contents + rel->r_offset + pos);
2947
2948 /* Write a final RVC NOP if need be. */
2949 if (nop_bytes % 4 != 0)
2950 bfd_put_16 (abfd, RVC_NOP, contents + rel->r_offset + pos);
2951
2952 /* Delete the excess bytes. */
2953 return riscv_relax_delete_bytes (abfd, sec, rel->r_offset + nop_bytes,
2954 rel->r_addend - nop_bytes);
2955}
2956
ff6f4d9b
PD		 2957/* Relax PC-relative references to GP-relative references. */
2958
2959static bfd_boolean
2960_bfd_riscv_relax_delete (bfd *abfd,
2961 asection *sec,
2962 asection *sym_sec ATTRIBUTE_UNUSED,
2963 struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
2964 Elf_Internal_Rela *rel,
2965 bfd_vma symval ATTRIBUTE_UNUSED,
2966 bfd_vma max_alignment ATTRIBUTE_UNUSED,
2967 bfd_vma reserve_size ATTRIBUTE_UNUSED,
2968 bfd_boolean *again ATTRIBUTE_UNUSED)
2969{
2970 if (!riscv_relax_delete_bytes(abfd, sec, rel->r_offset, rel->r_addend))
2971 return FALSE;
2972 rel->r_info = ELFNN_R_INFO(0, R_RISCV_NONE);
2973 return TRUE;
2974}
2975
2976/* Relax a section. Pass 0 shortens code sequences unless disabled. Pass 1
2977 deletes the bytes that pass 0 made obselete. Pass 2, which cannot be
2978 disabled, handles code alignment directives. */
e23eba97
NC		 2979
2980static bfd_boolean
2981_bfd_riscv_relax_section (bfd *abfd, asection *sec,
2982 struct bfd_link_info *info,
2983 bfd_boolean *again)
2984{
2985 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (abfd);
2986 struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info);
2987 struct bfd_elf_section_data *data = elf_section_data (sec);
2988 Elf_Internal_Rela *relocs;
2989 bfd_boolean ret = FALSE;
2990 unsigned int i;
45f76423 2991 bfd_vma max_alignment, reserve_size = 0;
e23eba97
NC		 2992
2993 *again = FALSE;
2994
2995 if (bfd_link_relocatable (info)
2996 || sec->sec_flg0
2997 || (sec->flags & SEC_RELOC) == 0
2998 || sec->reloc_count == 0
2999 || (info->disable_target_specific_optimizations
3000 && info->relax_pass == 0))
3001 return TRUE;
3002
3003 /* Read this BFD's relocs if we haven't done so already. */
3004 if (data->relocs)
3005 relocs = data->relocs;
3006 else if (!(relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
3007 info->keep_memory)))
3008 goto fail;
3009
fc3c5343
L		 3010 if (htab)
3011 {
3012 max_alignment = htab->max_alignment;
3013 if (max_alignment == (bfd_vma) -1)
3014 {
3015 max_alignment = _bfd_riscv_get_max_alignment (sec);
3016 htab->max_alignment = max_alignment;
3017 }
3018 }
3019 else
3020 max_alignment = _bfd_riscv_get_max_alignment (sec);
e23eba97
NC		 3021
3022 /* Examine and consider relaxing each reloc. */
3023 for (i = 0; i < sec->reloc_count; i++)
3024 {
3025 asection *sym_sec;
3026 Elf_Internal_Rela *rel = relocs + i;
45f76423 3027 relax_func_t relax_func;
e23eba97
NC		 3028 int type = ELFNN_R_TYPE (rel->r_info);
3029 bfd_vma symval;
3030
ff6f4d9b 3031 relax_func = NULL;
e23eba97
NC		 3032 if (info->relax_pass == 0)
3033 {
3034 if (type == R_RISCV_CALL || type == R_RISCV_CALL_PLT)
3035 relax_func = _bfd_riscv_relax_call;
3036 else if (type == R_RISCV_HI20
3037 || type == R_RISCV_LO12_I
3038 || type == R_RISCV_LO12_S)
3039 relax_func = _bfd_riscv_relax_lui;
45f76423
AW		 3040 else if (type == R_RISCV_TPREL_HI20
3041 || type == R_RISCV_TPREL_ADD
3042 || type == R_RISCV_TPREL_LO12_I
3043 || type == R_RISCV_TPREL_LO12_S)
e23eba97 3044 relax_func = _bfd_riscv_relax_tls_le;
45f76423
AW		 3045 else
3046 continue;
3047
3048 /* Only relax this reloc if it is paired with R_RISCV_RELAX. */
3049 if (i == sec->reloc_count - 1
3050 || ELFNN_R_TYPE ((rel + 1)->r_info) != R_RISCV_RELAX
3051 || rel->r_offset != (rel + 1)->r_offset)
3052 continue;
3053
3054 /* Skip over the R_RISCV_RELAX. */
3055 i++;
e23eba97 3056 }
ff6f4d9b
PD		 3057 else if (info->relax_pass == 1 && type == R_RISCV_DELETE)
3058 relax_func = _bfd_riscv_relax_delete;
3059 else if (info->relax_pass == 2 && type == R_RISCV_ALIGN)
e23eba97 3060 relax_func = _bfd_riscv_relax_align;
45f76423 3061 else
e23eba97
NC		 3062 continue;
3063
3064 data->relocs = relocs;
3065
3066 /* Read this BFD's contents if we haven't done so already. */
3067 if (!data->this_hdr.contents
3068 && !bfd_malloc_and_get_section (abfd, sec, &data->this_hdr.contents))
3069 goto fail;
3070
3071 /* Read this BFD's symbols if we haven't done so already. */
3072 if (symtab_hdr->sh_info != 0
3073 && !symtab_hdr->contents
3074 && !(symtab_hdr->contents =
3075 (unsigned char *) bfd_elf_get_elf_syms (abfd, symtab_hdr,
3076 symtab_hdr->sh_info,
3077 0, NULL, NULL, NULL)))
3078 goto fail;
3079
3080 /* Get the value of the symbol referred to by the reloc. */
3081 if (ELFNN_R_SYM (rel->r_info) < symtab_hdr->sh_info)
3082 {
3083 /* A local symbol. */
3084 Elf_Internal_Sym *isym = ((Elf_Internal_Sym *) symtab_hdr->contents
3085 + ELFNN_R_SYM (rel->r_info));
45f76423
AW		 3086 reserve_size = (isym->st_size - rel->r_addend) > isym->st_size
3087 ? 0 : isym->st_size - rel->r_addend;
e23eba97
NC		 3088
3089 if (isym->st_shndx == SHN_UNDEF)
3090 sym_sec = sec, symval = sec_addr (sec) + rel->r_offset;
3091 else
3092 {
3093 BFD_ASSERT (isym->st_shndx < elf_numsections (abfd));
3094 sym_sec = elf_elfsections (abfd)[isym->st_shndx]->bfd_section;
3095 if (sec_addr (sym_sec) == 0)
3096 continue;
3097 symval = sec_addr (sym_sec) + isym->st_value;
3098 }
3099 }
3100 else
3101 {
3102 unsigned long indx;
3103 struct elf_link_hash_entry *h;
3104
3105 indx = ELFNN_R_SYM (rel->r_info) - symtab_hdr->sh_info;
3106 h = elf_sym_hashes (abfd)[indx];
3107
3108 while (h->root.type == bfd_link_hash_indirect
3109 || h->root.type == bfd_link_hash_warning)
3110 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3111
3112 if (h->plt.offset != MINUS_ONE)
3113 symval = sec_addr (htab->elf.splt) + h->plt.offset;
3114 else if (h->root.u.def.section->output_section == NULL
3115 || (h->root.type != bfd_link_hash_defined
3116 && h->root.type != bfd_link_hash_defweak))
3117 continue;
3118 else
3119 symval = sec_addr (h->root.u.def.section) + h->root.u.def.value;
3120
45f76423
AW		 3121 if (h->type != STT_FUNC)
3122 reserve_size =
3123 (h->size - rel->r_addend) > h->size ? 0 : h->size - rel->r_addend;
e23eba97
NC		 3124 sym_sec = h->root.u.def.section;
3125 }
3126
3127 symval += rel->r_addend;
3128
3129 if (!relax_func (abfd, sec, sym_sec, info, rel, symval,
45f76423 3130 max_alignment, reserve_size, again))
e23eba97
NC		 3131 goto fail;
3132 }
3133
3134 ret = TRUE;
3135
3136fail:
3137 if (relocs != data->relocs)
3138 free (relocs);
3139
3140 return ret;
3141}
3142
3143#if ARCH_SIZE == 32
3144# define PRSTATUS_SIZE 0 /* FIXME */
3145# define PRSTATUS_OFFSET_PR_CURSIG 12
3146# define PRSTATUS_OFFSET_PR_PID 24
3147# define PRSTATUS_OFFSET_PR_REG 72
3148# define ELF_GREGSET_T_SIZE 128
3149# define PRPSINFO_SIZE 128
3150# define PRPSINFO_OFFSET_PR_PID 16
3151# define PRPSINFO_OFFSET_PR_FNAME 32
3152# define PRPSINFO_OFFSET_PR_PSARGS 48
3153#else
3154# define PRSTATUS_SIZE 376
3155# define PRSTATUS_OFFSET_PR_CURSIG 12
3156# define PRSTATUS_OFFSET_PR_PID 32
3157# define PRSTATUS_OFFSET_PR_REG 112
3158# define ELF_GREGSET_T_SIZE 256
3159# define PRPSINFO_SIZE 136
3160# define PRPSINFO_OFFSET_PR_PID 24
3161# define PRPSINFO_OFFSET_PR_FNAME 40
3162# define PRPSINFO_OFFSET_PR_PSARGS 56
3163#endif
3164
3165/* Support for core dump NOTE sections. */
3166
3167static bfd_boolean
3168riscv_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
3169{
3170 switch (note->descsz)
3171 {
3172 default:
3173 return FALSE;
3174
3175 case PRSTATUS_SIZE: /* sizeof(struct elf_prstatus) on Linux/RISC-V. */
3176 /* pr_cursig */
3177 elf_tdata (abfd)->core->signal
3178 = bfd_get_16 (abfd, note->descdata + PRSTATUS_OFFSET_PR_CURSIG);
3179
3180 /* pr_pid */
3181 elf_tdata (abfd)->core->lwpid
3182 = bfd_get_32 (abfd, note->descdata + PRSTATUS_OFFSET_PR_PID);
3183 break;
3184 }
3185
3186 /* Make a ".reg/999" section. */
3187 return _bfd_elfcore_make_pseudosection (abfd, ".reg", ELF_GREGSET_T_SIZE,
3188 note->descpos + PRSTATUS_OFFSET_PR_REG);
3189}
3190
3191static bfd_boolean
3192riscv_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
3193{
3194 switch (note->descsz)
3195 {
3196 default:
3197 return FALSE;
3198
3199 case PRPSINFO_SIZE: /* sizeof(struct elf_prpsinfo) on Linux/RISC-V. */
3200 /* pr_pid */
3201 elf_tdata (abfd)->core->pid
3202 = bfd_get_32 (abfd, note->descdata + PRPSINFO_OFFSET_PR_PID);
3203
3204 /* pr_fname */
3205 elf_tdata (abfd)->core->program = _bfd_elfcore_strndup
3206 (abfd, note->descdata + PRPSINFO_OFFSET_PR_FNAME, 16);
3207
3208 /* pr_psargs */
3209 elf_tdata (abfd)->core->command = _bfd_elfcore_strndup
3210 (abfd, note->descdata + PRPSINFO_OFFSET_PR_PSARGS, 80);
3211 break;
3212 }
3213
3214 /* Note that for some reason, a spurious space is tacked
3215 onto the end of the args in some (at least one anyway)
3216 implementations, so strip it off if it exists. */
3217
3218 {
3219 char *command = elf_tdata (abfd)->core->command;
3220 int n = strlen (command);
3221
3222 if (0 < n && command[n - 1] == ' ')
3223 command[n - 1] = '\0';
3224 }
3225
3226 return TRUE;
3227}
3228
640d6bfd
KLC		 3229/* Set the right mach type. */
3230static bfd_boolean
3231riscv_elf_object_p (bfd *abfd)
3232{
3233 /* There are only two mach types in RISCV currently. */
3234 if (strcmp (abfd->xvec->name, "elf32-littleriscv") == 0)
3235 bfd_default_set_arch_mach (abfd, bfd_arch_riscv, bfd_mach_riscv32);
3236 else
3237 bfd_default_set_arch_mach (abfd, bfd_arch_riscv, bfd_mach_riscv64);
3238
3239 return TRUE;
3240}
3241
e23eba97
NC		 3242
3243#define TARGET_LITTLE_SYM riscv_elfNN_vec
3244#define TARGET_LITTLE_NAME "elfNN-littleriscv"
3245
3246#define elf_backend_reloc_type_class riscv_reloc_type_class
3247
3248#define bfd_elfNN_bfd_reloc_name_lookup riscv_reloc_name_lookup
3249#define bfd_elfNN_bfd_link_hash_table_create riscv_elf_link_hash_table_create
3250#define bfd_elfNN_bfd_reloc_type_lookup riscv_reloc_type_lookup
3251#define bfd_elfNN_bfd_merge_private_bfd_data \
3252 _bfd_riscv_elf_merge_private_bfd_data
3253
3254#define elf_backend_copy_indirect_symbol riscv_elf_copy_indirect_symbol
3255#define elf_backend_create_dynamic_sections riscv_elf_create_dynamic_sections
3256#define elf_backend_check_relocs riscv_elf_check_relocs
3257#define elf_backend_adjust_dynamic_symbol riscv_elf_adjust_dynamic_symbol
3258#define elf_backend_size_dynamic_sections riscv_elf_size_dynamic_sections
3259#define elf_backend_relocate_section riscv_elf_relocate_section
3260#define elf_backend_finish_dynamic_symbol riscv_elf_finish_dynamic_symbol
3261#define elf_backend_finish_dynamic_sections riscv_elf_finish_dynamic_sections
3262#define elf_backend_gc_mark_hook riscv_elf_gc_mark_hook
e23eba97
NC		 3263#define elf_backend_plt_sym_val riscv_elf_plt_sym_val
3264#define elf_backend_grok_prstatus riscv_elf_grok_prstatus
3265#define elf_backend_grok_psinfo riscv_elf_grok_psinfo
640d6bfd 3266#define elf_backend_object_p riscv_elf_object_p
e23eba97
NC		 3267#define elf_info_to_howto_rel NULL
3268#define elf_info_to_howto riscv_info_to_howto_rela
3269#define bfd_elfNN_bfd_relax_section _bfd_riscv_relax_section
3270
3271#define elf_backend_init_index_section _bfd_elf_init_1_index_section
3272
3273#define elf_backend_can_gc_sections 1
3274#define elf_backend_can_refcount 1
3275#define elf_backend_want_got_plt 1
3276#define elf_backend_plt_readonly 1
3277#define elf_backend_plt_alignment 4
3278#define elf_backend_want_plt_sym 1
3279#define elf_backend_got_header_size (ARCH_SIZE / 8)
5474d94f 3280#define elf_backend_want_dynrelro 1
e23eba97
NC		 3281#define elf_backend_rela_normal 1
3282#define elf_backend_default_execstack 0
3283
3284#include "elfNN-target.h"
GDB Binutils - Deliverables
This page took 0.235996 seconds and 4 git commands to generate.