Update year range in copyright notice of all files.
[external/binutils.git] / bfd / elfnn-riscv.c
1 /* RISC-V-specific support for NN-bit ELF.
2    Copyright (C) 2011-2017 Free Software Foundation, Inc.
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
61 struct 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
77 struct 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
95 struct _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
121 struct riscv_elf_link_hash_table
122 {
123   struct elf_link_hash_table elf;
124
125   /* Short-cuts to get to dynamic linker sections.  */
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
138 static void
139 riscv_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
146 static void
147 riscv_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
170 static bfd_vma
171 riscv_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
185 static void
186 riscv_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
212 static void
213 riscv_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));
221   entry[1] = RISCV_ITYPE (LREG,  X_T3, X_T3, RISCV_PCREL_LOW_PART (got, addr));
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
228 static struct bfd_hash_entry *
229 link_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
259 static struct bfd_link_hash_table *
260 riscv_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
282 static bfd_boolean
283 riscv_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.  */
292   if (htab->sgot != NULL)
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
349 static bfd_boolean
350 riscv_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
364   if (!bfd_link_pic (info))
365     {
366       htab->sdyntdata =
367         bfd_make_section_anyway_with_flags (dynobj, ".tdata.dyn",
368                                             SEC_ALLOC | SEC_THREAD_LOCAL);
369     }
370
371   if (!htab->elf.splt || !htab->elf.srelplt || !htab->elf.sdynbss
372       || (!bfd_link_pic (info) && (!htab->elf.srelbss || !htab->sdyntdata)))
373     abort ();
374
375   return TRUE;
376 }
377
378 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
379
380 static void
381 riscv_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
430 static bfd_boolean
431 riscv_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
447 static bfd_boolean
448 riscv_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
480 static bfd_boolean
481 bad_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
495 static bfd_boolean
496 riscv_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
739 static asection *
740 riscv_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
759 static bfd_boolean
760 riscv_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
857 static bfd_boolean
858 riscv_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;
865   asection *s, *srel;
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.  */
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     }
978   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
979     {
980       srel->size += sizeof (ElfNN_External_Rela);
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
987   return _bfd_elf_adjust_dynamic_copy (info, h, s);
988 }
989
990 /* Allocate space in .plt, .got and associated reloc sections for
991    dynamic relocs.  */
992
993 static bfd_boolean
994 allocate_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
1196 static bfd_boolean
1197 readonly_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
1216 static bfd_boolean
1217 riscv_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
1341           || s == htab->elf.sdynbss
1342           || s == htab->elf.sdynrelro)
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
1439 static bfd_vma
1440 dtpoff (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
1450 static bfd_vma
1451 tpoff (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
1461 static bfd_vma
1462 riscv_global_pointer_value (struct bfd_link_info *info)
1463 {
1464   struct bfd_link_hash_entry *h;
1465
1466   h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
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
1475 static bfd_reloc_status_type
1476 perform_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:
1503     case R_RISCV_TPREL_I:
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:
1511     case R_RISCV_TPREL_S:
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:
1560     case R_RISCV_SUB6:
1561     case R_RISCV_SUB8:
1562     case R_RISCV_SUB16:
1563     case R_RISCV_SUB32:
1564     case R_RISCV_SUB64:
1565     case R_RISCV_SET6:
1566     case R_RISCV_SET8:
1567     case R_RISCV_SET16:
1568     case R_RISCV_SET32:
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
1587 typedef struct
1588 {
1589   bfd_vma address;
1590   bfd_vma value;
1591 } riscv_pcrel_hi_reloc;
1592
1593 typedef 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
1605 typedef struct
1606 {
1607   htab_t hi_relocs;
1608   riscv_pcrel_lo_reloc *lo_relocs;
1609 } riscv_pcrel_relocs;
1610
1611 static hashval_t
1612 riscv_pcrel_reloc_hash (const void *entry)
1613 {
1614   const riscv_pcrel_hi_reloc *e = entry;
1615   return (hashval_t)(e->address >> 2);
1616 }
1617
1618 static bfd_boolean
1619 riscv_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
1625 static bfd_boolean
1626 riscv_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
1635 static void
1636 riscv_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
1650 static bfd_boolean
1651 riscv_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
1665 static bfd_boolean
1666 riscv_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
1685 static bfd_boolean
1686 riscv_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
1739 static bfd_boolean
1740 riscv_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:
1834         case R_RISCV_RELAX:
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:
1848         case R_RISCV_SET6:
1849         case R_RISCV_SET8:
1850         case R_RISCV_SET16:
1851         case R_RISCV_SET32:
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
1945         case R_RISCV_SUB6:
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:
1975           relocation = tpoff (info, relocation);
1976           break;
1977
1978         case R_RISCV_TPREL_I:
1979         case R_RISCV_TPREL_S:
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             }
1989           else
1990             r = bfd_reloc_overflow;
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);
2286 out:
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
2294 static bfd_boolean
2295 riscv_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
2359       && !(riscv_elf_hash_entry (h)->tls_type & (GOT_TLS_GD | GOT_TLS_IE)))
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;
2403       asection *s;
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;
2411       if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
2412         s = htab->elf.sreldynrelro;
2413       else
2414         s = htab->elf.srelbss;
2415       riscv_elf_append_rela (output_bfd, s, &rela);
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
2428 static bfd_boolean
2429 riscv_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
2468 static bfd_boolean
2469 riscv_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);
2505         }
2506
2507       elf_section_data (splt->output_section)->this_hdr.sh_entsize
2508         = PLT_ENTRY_SIZE;
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
2555 static bfd_vma
2556 riscv_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
2562 static enum elf_reloc_type_class
2563 riscv_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
2583 static 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)
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));
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
2612   /* Disallow linking different float ABIs.  */
2613   if ((old_flags ^ new_flags) & EF_RISCV_FLOAT_ABI)
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
2625 fail:
2626   bfd_set_error (bfd_error_bad_value);
2627   return FALSE;
2628 }
2629
2630 /* Delete some bytes from a section while relaxing.  */
2631
2632 static bfd_boolean
2633 riscv_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
2703 typedef 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
2708 /* Relax AUIPC + JALR into JAL.  */
2709
2710 static 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,
2715                        bfd_vma max_alignment,
2716                        bfd_vma reserve_size ATTRIBUTE_UNUSED,
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
2774 static bfd_vma
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
2786   return (bfd_vma) 1 << max_alignment_power;
2787 }
2788
2789 /* Relax non-PIC global variable references.  */
2790
2791 static 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,
2798                       bfd_vma max_alignment,
2799                       bfd_vma reserve_size,
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
2812   /* Is the reference in range of x0 or gp?
2813      Valid gp range conservatively because of alignment issue.  */
2814   if (VALID_ITYPE_IMM (symval)
2815       || (symval >= gp
2816           && VALID_ITYPE_IMM (symval - gp + max_alignment + reserve_size))
2817       || (symval < gp
2818           && VALID_ITYPE_IMM (symval - gp - max_alignment - reserve_size)))
2819     {
2820       unsigned sym = ELFNN_R_SYM (rel->r_info);
2821       switch (ELFNN_R_TYPE (rel->r_info))
2822         {
2823         case R_RISCV_LO12_I:
2824           rel->r_info = ELFNN_R_INFO (sym, R_RISCV_GPREL_I);
2825           return TRUE;
2826
2827         case R_RISCV_LO12_S:
2828           rel->r_info = ELFNN_R_INFO (sym, R_RISCV_GPREL_S);
2829           return TRUE;
2830
2831         case R_RISCV_HI20:
2832           /* We can delete the unnecessary LUI and reloc.  */
2833           rel->r_info = ELFNN_R_INFO (0, R_RISCV_NONE);
2834           *again = TRUE;
2835           return riscv_relax_delete_bytes (abfd, sec, rel->r_offset, 4);
2836
2837         default:
2838           abort ();
2839         }
2840     }
2841
2842   /* Can we relax LUI to C.LUI?  Alignment might move the section forward;
2843      account for this assuming page alignment at worst.  */
2844   if (use_rvc
2845       && ELFNN_R_TYPE (rel->r_info) == R_RISCV_HI20
2846       && VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (symval))
2847       && VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (symval + ELF_MAXPAGESIZE)))
2848     {
2849       /* Replace LUI with C.LUI if legal (i.e., rd != x2/sp).  */
2850       bfd_vma lui = bfd_get_32 (abfd, contents + rel->r_offset);
2851       if (((lui >> OP_SH_RD) & OP_MASK_RD) == X_SP)
2852         return TRUE;
2853
2854       lui = (lui & (OP_MASK_RD << OP_SH_RD)) | MATCH_C_LUI;
2855       bfd_put_32 (abfd, lui, contents + rel->r_offset);
2856
2857       /* Replace the R_RISCV_HI20 reloc.  */
2858       rel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info), R_RISCV_RVC_LUI);
2859
2860       *again = TRUE;
2861       return riscv_relax_delete_bytes (abfd, sec, rel->r_offset + 2, 2);
2862     }
2863
2864   return TRUE;
2865 }
2866
2867 /* Relax non-PIC TLS references.  */
2868
2869 static bfd_boolean
2870 _bfd_riscv_relax_tls_le (bfd *abfd,
2871                          asection *sec,
2872                          asection *sym_sec ATTRIBUTE_UNUSED,
2873                          struct bfd_link_info *link_info,
2874                          Elf_Internal_Rela *rel,
2875                          bfd_vma symval,
2876                          bfd_vma max_alignment ATTRIBUTE_UNUSED,
2877                          bfd_vma reserve_size ATTRIBUTE_UNUSED,
2878                          bfd_boolean *again)
2879 {
2880   /* See if this symbol is in range of tp.  */
2881   if (RISCV_CONST_HIGH_PART (tpoff (link_info, symval)) != 0)
2882     return TRUE;
2883
2884   BFD_ASSERT (rel->r_offset + 4 <= sec->size);
2885   switch (ELFNN_R_TYPE (rel->r_info))
2886     {
2887     case R_RISCV_TPREL_LO12_I:
2888       rel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info), R_RISCV_TPREL_I);
2889       return TRUE;
2890
2891     case R_RISCV_TPREL_LO12_S:
2892       rel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info), R_RISCV_TPREL_S);
2893       return TRUE;
2894
2895     case R_RISCV_TPREL_HI20:
2896     case R_RISCV_TPREL_ADD:
2897       /* We can delete the unnecessary instruction and reloc.  */
2898       rel->r_info = ELFNN_R_INFO (0, R_RISCV_NONE);
2899       *again = TRUE;
2900       return riscv_relax_delete_bytes (abfd, sec, rel->r_offset, 4);
2901
2902     default:
2903       abort ();
2904     }
2905 }
2906
2907 /* Implement R_RISCV_ALIGN by deleting excess alignment NOPs.  */
2908
2909 static bfd_boolean
2910 _bfd_riscv_relax_align (bfd *abfd, asection *sec,
2911                         asection *sym_sec ATTRIBUTE_UNUSED,
2912                         struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
2913                         Elf_Internal_Rela *rel,
2914                         bfd_vma symval,
2915                         bfd_vma max_alignment ATTRIBUTE_UNUSED,
2916                         bfd_vma reserve_size ATTRIBUTE_UNUSED,
2917                         bfd_boolean *again ATTRIBUTE_UNUSED)
2918 {
2919   bfd_byte *contents = elf_section_data (sec)->this_hdr.contents;
2920   bfd_vma alignment = 1, pos;
2921   while (alignment <= rel->r_addend)
2922     alignment *= 2;
2923
2924   symval -= rel->r_addend;
2925   bfd_vma aligned_addr = ((symval - 1) & ~(alignment - 1)) + alignment;
2926   bfd_vma nop_bytes = aligned_addr - symval;
2927
2928   /* Once we've handled an R_RISCV_ALIGN, we can't relax anything else.  */
2929   sec->sec_flg0 = TRUE;
2930
2931   /* Make sure there are enough NOPs to actually achieve the alignment.  */
2932   if (rel->r_addend < nop_bytes)
2933     return FALSE;
2934
2935   /* Delete the reloc.  */
2936   rel->r_info = ELFNN_R_INFO (0, R_RISCV_NONE);
2937
2938   /* If the number of NOPs is already correct, there's nothing to do.  */
2939   if (nop_bytes == rel->r_addend)
2940     return TRUE;
2941
2942   /* Write as many RISC-V NOPs as we need.  */
2943   for (pos = 0; pos < (nop_bytes & -4); pos += 4)
2944     bfd_put_32 (abfd, RISCV_NOP, contents + rel->r_offset + pos);
2945
2946   /* Write a final RVC NOP if need be.  */
2947   if (nop_bytes % 4 != 0)
2948     bfd_put_16 (abfd, RVC_NOP, contents + rel->r_offset + pos);
2949
2950   /* Delete the excess bytes.  */
2951   return riscv_relax_delete_bytes (abfd, sec, rel->r_offset + nop_bytes,
2952                                    rel->r_addend - nop_bytes);
2953 }
2954
2955 /* Relax a section.  Pass 0 shortens code sequences unless disabled.
2956    Pass 1, which cannot be disabled, handles code alignment directives.  */
2957
2958 static bfd_boolean
2959 _bfd_riscv_relax_section (bfd *abfd, asection *sec,
2960                           struct bfd_link_info *info,
2961                           bfd_boolean *again)
2962 {
2963   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (abfd);
2964   struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info);
2965   struct bfd_elf_section_data *data = elf_section_data (sec);
2966   Elf_Internal_Rela *relocs;
2967   bfd_boolean ret = FALSE;
2968   unsigned int i;
2969   bfd_vma max_alignment, reserve_size = 0;
2970
2971   *again = FALSE;
2972
2973   if (bfd_link_relocatable (info)
2974       || sec->sec_flg0
2975       || (sec->flags & SEC_RELOC) == 0
2976       || sec->reloc_count == 0
2977       || (info->disable_target_specific_optimizations
2978           && info->relax_pass == 0))
2979     return TRUE;
2980
2981   /* Read this BFD's relocs if we haven't done so already.  */
2982   if (data->relocs)
2983     relocs = data->relocs;
2984   else if (!(relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
2985                                                  info->keep_memory)))
2986     goto fail;
2987
2988   max_alignment = _bfd_riscv_get_max_alignment (sec);
2989
2990   /* Examine and consider relaxing each reloc.  */
2991   for (i = 0; i < sec->reloc_count; i++)
2992     {
2993       asection *sym_sec;
2994       Elf_Internal_Rela *rel = relocs + i;
2995       relax_func_t relax_func;
2996       int type = ELFNN_R_TYPE (rel->r_info);
2997       bfd_vma symval;
2998
2999       if (info->relax_pass == 0)
3000         {
3001           if (type == R_RISCV_CALL || type == R_RISCV_CALL_PLT)
3002             relax_func = _bfd_riscv_relax_call;
3003           else if (type == R_RISCV_HI20
3004                    || type == R_RISCV_LO12_I
3005                    || type == R_RISCV_LO12_S)
3006             relax_func = _bfd_riscv_relax_lui;
3007           else if (type == R_RISCV_TPREL_HI20
3008                    || type == R_RISCV_TPREL_ADD
3009                    || type == R_RISCV_TPREL_LO12_I
3010                    || type == R_RISCV_TPREL_LO12_S)
3011             relax_func = _bfd_riscv_relax_tls_le;
3012           else
3013             continue;
3014
3015           /* Only relax this reloc if it is paired with R_RISCV_RELAX.  */
3016           if (i == sec->reloc_count - 1
3017               || ELFNN_R_TYPE ((rel + 1)->r_info) != R_RISCV_RELAX
3018               || rel->r_offset != (rel + 1)->r_offset)
3019             continue;
3020
3021           /* Skip over the R_RISCV_RELAX.  */
3022           i++;
3023         }
3024       else if (type == R_RISCV_ALIGN)
3025         relax_func = _bfd_riscv_relax_align;
3026       else
3027         continue;
3028
3029       data->relocs = relocs;
3030
3031       /* Read this BFD's contents if we haven't done so already.  */
3032       if (!data->this_hdr.contents
3033           && !bfd_malloc_and_get_section (abfd, sec, &data->this_hdr.contents))
3034         goto fail;
3035
3036       /* Read this BFD's symbols if we haven't done so already.  */
3037       if (symtab_hdr->sh_info != 0
3038           && !symtab_hdr->contents
3039           && !(symtab_hdr->contents =
3040                (unsigned char *) bfd_elf_get_elf_syms (abfd, symtab_hdr,
3041                                                        symtab_hdr->sh_info,
3042                                                        0, NULL, NULL, NULL)))
3043         goto fail;
3044
3045       /* Get the value of the symbol referred to by the reloc.  */
3046       if (ELFNN_R_SYM (rel->r_info) < symtab_hdr->sh_info)
3047         {
3048           /* A local symbol.  */
3049           Elf_Internal_Sym *isym = ((Elf_Internal_Sym *) symtab_hdr->contents
3050                                     + ELFNN_R_SYM (rel->r_info));
3051           reserve_size = (isym->st_size - rel->r_addend) > isym->st_size
3052             ? 0 : isym->st_size - rel->r_addend;
3053
3054           if (isym->st_shndx == SHN_UNDEF)
3055             sym_sec = sec, symval = sec_addr (sec) + rel->r_offset;
3056           else
3057             {
3058               BFD_ASSERT (isym->st_shndx < elf_numsections (abfd));
3059               sym_sec = elf_elfsections (abfd)[isym->st_shndx]->bfd_section;
3060               if (sec_addr (sym_sec) == 0)
3061                 continue;
3062               symval = sec_addr (sym_sec) + isym->st_value;
3063             }
3064         }
3065       else
3066         {
3067           unsigned long indx;
3068           struct elf_link_hash_entry *h;
3069
3070           indx = ELFNN_R_SYM (rel->r_info) - symtab_hdr->sh_info;
3071           h = elf_sym_hashes (abfd)[indx];
3072
3073           while (h->root.type == bfd_link_hash_indirect
3074                  || h->root.type == bfd_link_hash_warning)
3075             h = (struct elf_link_hash_entry *) h->root.u.i.link;
3076
3077           if (h->plt.offset != MINUS_ONE)
3078             symval = sec_addr (htab->elf.splt) + h->plt.offset;
3079           else if (h->root.u.def.section->output_section == NULL
3080                    || (h->root.type != bfd_link_hash_defined
3081                        && h->root.type != bfd_link_hash_defweak))
3082             continue;
3083           else
3084             symval = sec_addr (h->root.u.def.section) + h->root.u.def.value;
3085
3086           if (h->type != STT_FUNC)
3087             reserve_size =
3088               (h->size - rel->r_addend) > h->size ? 0 : h->size - rel->r_addend;
3089           sym_sec = h->root.u.def.section;
3090         }
3091
3092       symval += rel->r_addend;
3093
3094       if (!relax_func (abfd, sec, sym_sec, info, rel, symval,
3095                        max_alignment, reserve_size, again))
3096         goto fail;
3097     }
3098
3099   ret = TRUE;
3100
3101 fail:
3102   if (relocs != data->relocs)
3103     free (relocs);
3104
3105   return ret;
3106 }
3107
3108 #if ARCH_SIZE == 32
3109 # define PRSTATUS_SIZE                  0 /* FIXME */
3110 # define PRSTATUS_OFFSET_PR_CURSIG      12
3111 # define PRSTATUS_OFFSET_PR_PID         24
3112 # define PRSTATUS_OFFSET_PR_REG         72
3113 # define ELF_GREGSET_T_SIZE             128
3114 # define PRPSINFO_SIZE                  128
3115 # define PRPSINFO_OFFSET_PR_PID         16
3116 # define PRPSINFO_OFFSET_PR_FNAME       32
3117 # define PRPSINFO_OFFSET_PR_PSARGS      48
3118 #else
3119 # define PRSTATUS_SIZE                  376
3120 # define PRSTATUS_OFFSET_PR_CURSIG      12
3121 # define PRSTATUS_OFFSET_PR_PID         32
3122 # define PRSTATUS_OFFSET_PR_REG         112
3123 # define ELF_GREGSET_T_SIZE             256
3124 # define PRPSINFO_SIZE                  136
3125 # define PRPSINFO_OFFSET_PR_PID         24
3126 # define PRPSINFO_OFFSET_PR_FNAME       40
3127 # define PRPSINFO_OFFSET_PR_PSARGS      56
3128 #endif
3129
3130 /* Support for core dump NOTE sections.  */
3131
3132 static bfd_boolean
3133 riscv_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
3134 {
3135   switch (note->descsz)
3136     {
3137       default:
3138         return FALSE;
3139
3140       case PRSTATUS_SIZE:  /* sizeof(struct elf_prstatus) on Linux/RISC-V.  */
3141         /* pr_cursig */
3142         elf_tdata (abfd)->core->signal
3143           = bfd_get_16 (abfd, note->descdata + PRSTATUS_OFFSET_PR_CURSIG);
3144
3145         /* pr_pid */
3146         elf_tdata (abfd)->core->lwpid
3147           = bfd_get_32 (abfd, note->descdata + PRSTATUS_OFFSET_PR_PID);
3148         break;
3149     }
3150
3151   /* Make a ".reg/999" section.  */
3152   return _bfd_elfcore_make_pseudosection (abfd, ".reg", ELF_GREGSET_T_SIZE,
3153                                           note->descpos + PRSTATUS_OFFSET_PR_REG);
3154 }
3155
3156 static bfd_boolean
3157 riscv_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
3158 {
3159   switch (note->descsz)
3160     {
3161       default:
3162         return FALSE;
3163
3164       case PRPSINFO_SIZE: /* sizeof(struct elf_prpsinfo) on Linux/RISC-V.  */
3165         /* pr_pid */
3166         elf_tdata (abfd)->core->pid
3167           = bfd_get_32 (abfd, note->descdata + PRPSINFO_OFFSET_PR_PID);
3168
3169         /* pr_fname */
3170         elf_tdata (abfd)->core->program = _bfd_elfcore_strndup
3171           (abfd, note->descdata + PRPSINFO_OFFSET_PR_FNAME, 16);
3172
3173         /* pr_psargs */
3174         elf_tdata (abfd)->core->command = _bfd_elfcore_strndup
3175           (abfd, note->descdata + PRPSINFO_OFFSET_PR_PSARGS, 80);
3176         break;
3177     }
3178
3179   /* Note that for some reason, a spurious space is tacked
3180      onto the end of the args in some (at least one anyway)
3181      implementations, so strip it off if it exists.  */
3182
3183   {
3184     char *command = elf_tdata (abfd)->core->command;
3185     int n = strlen (command);
3186
3187     if (0 < n && command[n - 1] == ' ')
3188       command[n - 1] = '\0';
3189   }
3190
3191   return TRUE;
3192 }
3193
3194
3195 #define TARGET_LITTLE_SYM               riscv_elfNN_vec
3196 #define TARGET_LITTLE_NAME              "elfNN-littleriscv"
3197
3198 #define elf_backend_reloc_type_class         riscv_reloc_type_class
3199
3200 #define bfd_elfNN_bfd_reloc_name_lookup      riscv_reloc_name_lookup
3201 #define bfd_elfNN_bfd_link_hash_table_create riscv_elf_link_hash_table_create
3202 #define bfd_elfNN_bfd_reloc_type_lookup      riscv_reloc_type_lookup
3203 #define bfd_elfNN_bfd_merge_private_bfd_data \
3204   _bfd_riscv_elf_merge_private_bfd_data
3205
3206 #define elf_backend_copy_indirect_symbol     riscv_elf_copy_indirect_symbol
3207 #define elf_backend_create_dynamic_sections  riscv_elf_create_dynamic_sections
3208 #define elf_backend_check_relocs             riscv_elf_check_relocs
3209 #define elf_backend_adjust_dynamic_symbol    riscv_elf_adjust_dynamic_symbol
3210 #define elf_backend_size_dynamic_sections    riscv_elf_size_dynamic_sections
3211 #define elf_backend_relocate_section         riscv_elf_relocate_section
3212 #define elf_backend_finish_dynamic_symbol    riscv_elf_finish_dynamic_symbol
3213 #define elf_backend_finish_dynamic_sections  riscv_elf_finish_dynamic_sections
3214 #define elf_backend_gc_mark_hook             riscv_elf_gc_mark_hook
3215 #define elf_backend_gc_sweep_hook            riscv_elf_gc_sweep_hook
3216 #define elf_backend_plt_sym_val              riscv_elf_plt_sym_val
3217 #define elf_backend_grok_prstatus            riscv_elf_grok_prstatus
3218 #define elf_backend_grok_psinfo              riscv_elf_grok_psinfo
3219 #define elf_info_to_howto_rel                NULL
3220 #define elf_info_to_howto                    riscv_info_to_howto_rela
3221 #define bfd_elfNN_bfd_relax_section          _bfd_riscv_relax_section
3222
3223 #define elf_backend_init_index_section       _bfd_elf_init_1_index_section
3224
3225 #define elf_backend_can_gc_sections     1
3226 #define elf_backend_can_refcount        1
3227 #define elf_backend_want_got_plt        1
3228 #define elf_backend_plt_readonly        1
3229 #define elf_backend_plt_alignment       4
3230 #define elf_backend_want_plt_sym        1
3231 #define elf_backend_got_header_size     (ARCH_SIZE / 8)
3232 #define elf_backend_want_dynrelro       1
3233 #define elf_backend_rela_normal         1
3234 #define elf_backend_default_execstack   0
3235
3236 #include "elfNN-target.h"