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