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