RISC-V: Merge ELF attribute for ld.
[external/binutils.git] / bfd / elfnn-riscv.c
1 /* RISC-V-specific support for NN-bit ELF.
2    Copyright (C) 2011-2019 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           || s == htab->sdyntdata)
1279         {
1280           /* Strip this section if we don't need it; see the
1281              comment below.  */
1282         }
1283       else if (strncmp (s->name, ".rela", 5) == 0)
1284         {
1285           if (s->size != 0)
1286             {
1287               /* We use the reloc_count field as a counter if we need
1288                  to copy relocs into the output file.  */
1289               s->reloc_count = 0;
1290             }
1291         }
1292       else
1293         {
1294           /* It's not one of our sections.  */
1295           continue;
1296         }
1297
1298       if (s->size == 0)
1299         {
1300           /* If we don't need this section, strip it from the
1301              output file.  This is mostly to handle .rela.bss and
1302              .rela.plt.  We must create both sections in
1303              create_dynamic_sections, because they must be created
1304              before the linker maps input sections to output
1305              sections.  The linker does that before
1306              adjust_dynamic_symbol is called, and it is that
1307              function which decides whether anything needs to go
1308              into these sections.  */
1309           s->flags |= SEC_EXCLUDE;
1310           continue;
1311         }
1312
1313       if ((s->flags & SEC_HAS_CONTENTS) == 0)
1314         continue;
1315
1316       /* Allocate memory for the section contents.  Zero the memory
1317          for the benefit of .rela.plt, which has 4 unused entries
1318          at the beginning, and we don't want garbage.  */
1319       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
1320       if (s->contents == NULL)
1321         return FALSE;
1322     }
1323
1324   if (elf_hash_table (info)->dynamic_sections_created)
1325     {
1326       /* Add some entries to the .dynamic section.  We fill in the
1327          values later, in riscv_elf_finish_dynamic_sections, but we
1328          must add the entries now so that we get the correct size for
1329          the .dynamic section.  The DT_DEBUG entry is filled in by the
1330          dynamic linker and used by the debugger.  */
1331 #define add_dynamic_entry(TAG, VAL) \
1332   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1333
1334       if (bfd_link_executable (info))
1335         {
1336           if (!add_dynamic_entry (DT_DEBUG, 0))
1337             return FALSE;
1338         }
1339
1340       if (htab->elf.srelplt->size != 0)
1341         {
1342           if (!add_dynamic_entry (DT_PLTGOT, 0)
1343               || !add_dynamic_entry (DT_PLTRELSZ, 0)
1344               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
1345               || !add_dynamic_entry (DT_JMPREL, 0))
1346             return FALSE;
1347         }
1348
1349       if (!add_dynamic_entry (DT_RELA, 0)
1350           || !add_dynamic_entry (DT_RELASZ, 0)
1351           || !add_dynamic_entry (DT_RELAENT, sizeof (ElfNN_External_Rela)))
1352         return FALSE;
1353
1354       /* If any dynamic relocs apply to a read-only section,
1355          then we need a DT_TEXTREL entry.  */
1356       if ((info->flags & DF_TEXTREL) == 0)
1357         elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
1358
1359       if (info->flags & DF_TEXTREL)
1360         {
1361           if (!add_dynamic_entry (DT_TEXTREL, 0))
1362             return FALSE;
1363         }
1364     }
1365 #undef add_dynamic_entry
1366
1367   return TRUE;
1368 }
1369
1370 #define TP_OFFSET 0
1371 #define DTP_OFFSET 0x800
1372
1373 /* Return the relocation value for a TLS dtp-relative reloc.  */
1374
1375 static bfd_vma
1376 dtpoff (struct bfd_link_info *info, bfd_vma address)
1377 {
1378   /* If tls_sec is NULL, we should have signalled an error already.  */
1379   if (elf_hash_table (info)->tls_sec == NULL)
1380     return 0;
1381   return address - elf_hash_table (info)->tls_sec->vma - DTP_OFFSET;
1382 }
1383
1384 /* Return the relocation value for a static TLS tp-relative relocation.  */
1385
1386 static bfd_vma
1387 tpoff (struct bfd_link_info *info, bfd_vma address)
1388 {
1389   /* If tls_sec is NULL, we should have signalled an error already.  */
1390   if (elf_hash_table (info)->tls_sec == NULL)
1391     return 0;
1392   return address - elf_hash_table (info)->tls_sec->vma - TP_OFFSET;
1393 }
1394
1395 /* Return the global pointer's value, or 0 if it is not in use.  */
1396
1397 static bfd_vma
1398 riscv_global_pointer_value (struct bfd_link_info *info)
1399 {
1400   struct bfd_link_hash_entry *h;
1401
1402   h = bfd_link_hash_lookup (info->hash, RISCV_GP_SYMBOL, FALSE, FALSE, TRUE);
1403   if (h == NULL || h->type != bfd_link_hash_defined)
1404     return 0;
1405
1406   return h->u.def.value + sec_addr (h->u.def.section);
1407 }
1408
1409 /* Emplace a static relocation.  */
1410
1411 static bfd_reloc_status_type
1412 perform_relocation (const reloc_howto_type *howto,
1413                     const Elf_Internal_Rela *rel,
1414                     bfd_vma value,
1415                     asection *input_section,
1416                     bfd *input_bfd,
1417                     bfd_byte *contents)
1418 {
1419   if (howto->pc_relative)
1420     value -= sec_addr (input_section) + rel->r_offset;
1421   value += rel->r_addend;
1422
1423   switch (ELFNN_R_TYPE (rel->r_info))
1424     {
1425     case R_RISCV_HI20:
1426     case R_RISCV_TPREL_HI20:
1427     case R_RISCV_PCREL_HI20:
1428     case R_RISCV_GOT_HI20:
1429     case R_RISCV_TLS_GOT_HI20:
1430     case R_RISCV_TLS_GD_HI20:
1431       if (ARCH_SIZE > 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (value)))
1432         return bfd_reloc_overflow;
1433       value = ENCODE_UTYPE_IMM (RISCV_CONST_HIGH_PART (value));
1434       break;
1435
1436     case R_RISCV_LO12_I:
1437     case R_RISCV_GPREL_I:
1438     case R_RISCV_TPREL_LO12_I:
1439     case R_RISCV_TPREL_I:
1440     case R_RISCV_PCREL_LO12_I:
1441       value = ENCODE_ITYPE_IMM (value);
1442       break;
1443
1444     case R_RISCV_LO12_S:
1445     case R_RISCV_GPREL_S:
1446     case R_RISCV_TPREL_LO12_S:
1447     case R_RISCV_TPREL_S:
1448     case R_RISCV_PCREL_LO12_S:
1449       value = ENCODE_STYPE_IMM (value);
1450       break;
1451
1452     case R_RISCV_CALL:
1453     case R_RISCV_CALL_PLT:
1454       if (ARCH_SIZE > 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (value)))
1455         return bfd_reloc_overflow;
1456       value = ENCODE_UTYPE_IMM (RISCV_CONST_HIGH_PART (value))
1457               | (ENCODE_ITYPE_IMM (value) << 32);
1458       break;
1459
1460     case R_RISCV_JAL:
1461       if (!VALID_UJTYPE_IMM (value))
1462         return bfd_reloc_overflow;
1463       value = ENCODE_UJTYPE_IMM (value);
1464       break;
1465
1466     case R_RISCV_BRANCH:
1467       if (!VALID_SBTYPE_IMM (value))
1468         return bfd_reloc_overflow;
1469       value = ENCODE_SBTYPE_IMM (value);
1470       break;
1471
1472     case R_RISCV_RVC_BRANCH:
1473       if (!VALID_RVC_B_IMM (value))
1474         return bfd_reloc_overflow;
1475       value = ENCODE_RVC_B_IMM (value);
1476       break;
1477
1478     case R_RISCV_RVC_JUMP:
1479       if (!VALID_RVC_J_IMM (value))
1480         return bfd_reloc_overflow;
1481       value = ENCODE_RVC_J_IMM (value);
1482       break;
1483
1484     case R_RISCV_RVC_LUI:
1485       if (!VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (value)))
1486         return bfd_reloc_overflow;
1487       value = ENCODE_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (value));
1488       break;
1489
1490     case R_RISCV_32:
1491     case R_RISCV_64:
1492     case R_RISCV_ADD8:
1493     case R_RISCV_ADD16:
1494     case R_RISCV_ADD32:
1495     case R_RISCV_ADD64:
1496     case R_RISCV_SUB6:
1497     case R_RISCV_SUB8:
1498     case R_RISCV_SUB16:
1499     case R_RISCV_SUB32:
1500     case R_RISCV_SUB64:
1501     case R_RISCV_SET6:
1502     case R_RISCV_SET8:
1503     case R_RISCV_SET16:
1504     case R_RISCV_SET32:
1505     case R_RISCV_32_PCREL:
1506     case R_RISCV_TLS_DTPREL32:
1507     case R_RISCV_TLS_DTPREL64:
1508       break;
1509
1510     case R_RISCV_DELETE:
1511       return bfd_reloc_ok;
1512
1513     default:
1514       return bfd_reloc_notsupported;
1515     }
1516
1517   bfd_vma word = bfd_get (howto->bitsize, input_bfd, contents + rel->r_offset);
1518   word = (word & ~howto->dst_mask) | (value & howto->dst_mask);
1519   bfd_put (howto->bitsize, input_bfd, word, contents + rel->r_offset);
1520
1521   return bfd_reloc_ok;
1522 }
1523
1524 /* Remember all PC-relative high-part relocs we've encountered to help us
1525    later resolve the corresponding low-part relocs.  */
1526
1527 typedef struct
1528 {
1529   bfd_vma address;
1530   bfd_vma value;
1531 } riscv_pcrel_hi_reloc;
1532
1533 typedef struct riscv_pcrel_lo_reloc
1534 {
1535   asection *                     input_section;
1536   struct bfd_link_info *         info;
1537   reloc_howto_type *             howto;
1538   const Elf_Internal_Rela *      reloc;
1539   bfd_vma                        addr;
1540   const char *                   name;
1541   bfd_byte *                     contents;
1542   struct riscv_pcrel_lo_reloc *  next;
1543 } riscv_pcrel_lo_reloc;
1544
1545 typedef struct
1546 {
1547   htab_t hi_relocs;
1548   riscv_pcrel_lo_reloc *lo_relocs;
1549 } riscv_pcrel_relocs;
1550
1551 static hashval_t
1552 riscv_pcrel_reloc_hash (const void *entry)
1553 {
1554   const riscv_pcrel_hi_reloc *e = entry;
1555   return (hashval_t)(e->address >> 2);
1556 }
1557
1558 static bfd_boolean
1559 riscv_pcrel_reloc_eq (const void *entry1, const void *entry2)
1560 {
1561   const riscv_pcrel_hi_reloc *e1 = entry1, *e2 = entry2;
1562   return e1->address == e2->address;
1563 }
1564
1565 static bfd_boolean
1566 riscv_init_pcrel_relocs (riscv_pcrel_relocs *p)
1567 {
1568
1569   p->lo_relocs = NULL;
1570   p->hi_relocs = htab_create (1024, riscv_pcrel_reloc_hash,
1571                               riscv_pcrel_reloc_eq, free);
1572   return p->hi_relocs != NULL;
1573 }
1574
1575 static void
1576 riscv_free_pcrel_relocs (riscv_pcrel_relocs *p)
1577 {
1578   riscv_pcrel_lo_reloc *cur = p->lo_relocs;
1579
1580   while (cur != NULL)
1581     {
1582       riscv_pcrel_lo_reloc *next = cur->next;
1583       free (cur);
1584       cur = next;
1585     }
1586
1587   htab_delete (p->hi_relocs);
1588 }
1589
1590 static bfd_boolean
1591 riscv_zero_pcrel_hi_reloc (Elf_Internal_Rela *rel,
1592                            struct bfd_link_info *info,
1593                            bfd_vma pc,
1594                            bfd_vma addr,
1595                            bfd_byte *contents,
1596                            const reloc_howto_type *howto,
1597                            bfd *input_bfd)
1598 {
1599   /* We may need to reference low addreses in PC-relative modes even when the
1600    * PC is far away from these addresses.  For example, undefweak references
1601    * need to produce the address 0 when linked.  As 0 is far from the arbitrary
1602    * addresses that we can link PC-relative programs at, the linker can't
1603    * actually relocate references to those symbols.  In order to allow these
1604    * programs to work we simply convert the PC-relative auipc sequences to
1605    * 0-relative lui sequences.  */
1606   if (bfd_link_pic (info))
1607     return FALSE;
1608
1609   /* If it's possible to reference the symbol using auipc we do so, as that's
1610    * more in the spirit of the PC-relative relocations we're processing.  */
1611   bfd_vma offset = addr - pc;
1612   if (ARCH_SIZE == 32 || VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (offset)))
1613     return FALSE;
1614
1615   /* If it's impossible to reference this with a LUI-based offset then don't
1616    * bother to convert it at all so users still see the PC-relative relocation
1617    * in the truncation message.  */
1618   if (ARCH_SIZE > 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (addr)))
1619     return FALSE;
1620
1621   rel->r_info = ELFNN_R_INFO(addr, R_RISCV_HI20);
1622
1623   bfd_vma insn = bfd_get(howto->bitsize, input_bfd, contents + rel->r_offset);
1624   insn = (insn & ~MASK_AUIPC) | MATCH_LUI;
1625   bfd_put(howto->bitsize, input_bfd, insn, contents + rel->r_offset);
1626   return TRUE;
1627 }
1628
1629 static bfd_boolean
1630 riscv_record_pcrel_hi_reloc (riscv_pcrel_relocs *p, bfd_vma addr,
1631                              bfd_vma value, bfd_boolean absolute)
1632 {
1633   bfd_vma offset = absolute ? value : value - addr;
1634   riscv_pcrel_hi_reloc entry = {addr, offset};
1635   riscv_pcrel_hi_reloc **slot =
1636     (riscv_pcrel_hi_reloc **) htab_find_slot (p->hi_relocs, &entry, INSERT);
1637
1638   BFD_ASSERT (*slot == NULL);
1639   *slot = (riscv_pcrel_hi_reloc *) bfd_malloc (sizeof (riscv_pcrel_hi_reloc));
1640   if (*slot == NULL)
1641     return FALSE;
1642   **slot = entry;
1643   return TRUE;
1644 }
1645
1646 static bfd_boolean
1647 riscv_record_pcrel_lo_reloc (riscv_pcrel_relocs *p,
1648                              asection *input_section,
1649                              struct bfd_link_info *info,
1650                              reloc_howto_type *howto,
1651                              const Elf_Internal_Rela *reloc,
1652                              bfd_vma addr,
1653                              const char *name,
1654                              bfd_byte *contents)
1655 {
1656   riscv_pcrel_lo_reloc *entry;
1657   entry = (riscv_pcrel_lo_reloc *) bfd_malloc (sizeof (riscv_pcrel_lo_reloc));
1658   if (entry == NULL)
1659     return FALSE;
1660   *entry = (riscv_pcrel_lo_reloc) {input_section, info, howto, reloc, addr,
1661                                    name, contents, p->lo_relocs};
1662   p->lo_relocs = entry;
1663   return TRUE;
1664 }
1665
1666 static bfd_boolean
1667 riscv_resolve_pcrel_lo_relocs (riscv_pcrel_relocs *p)
1668 {
1669   riscv_pcrel_lo_reloc *r;
1670
1671   for (r = p->lo_relocs; r != NULL; r = r->next)
1672     {
1673       bfd *input_bfd = r->input_section->owner;
1674
1675       riscv_pcrel_hi_reloc search = {r->addr, 0};
1676       riscv_pcrel_hi_reloc *entry = htab_find (p->hi_relocs, &search);
1677       if (entry == NULL
1678           /* Check for overflow into bit 11 when adding reloc addend.  */
1679           || (! (entry->value & 0x800)
1680               && ((entry->value + r->reloc->r_addend) & 0x800)))
1681         {
1682           char *string = (entry == NULL
1683                           ? "%pcrel_lo missing matching %pcrel_hi"
1684                           : "%pcrel_lo overflow with an addend");
1685           (*r->info->callbacks->reloc_dangerous)
1686             (r->info, string, input_bfd, r->input_section, r->reloc->r_offset);
1687           return TRUE;
1688         }
1689
1690       perform_relocation (r->howto, r->reloc, entry->value, r->input_section,
1691                           input_bfd, r->contents);
1692     }
1693
1694   return TRUE;
1695 }
1696
1697 /* Relocate a RISC-V ELF section.
1698
1699    The RELOCATE_SECTION function is called by the new ELF backend linker
1700    to handle the relocations for a section.
1701
1702    The relocs are always passed as Rela structures.
1703
1704    This function is responsible for adjusting the section contents as
1705    necessary, and (if generating a relocatable output file) adjusting
1706    the reloc addend as necessary.
1707
1708    This function does not have to worry about setting the reloc
1709    address or the reloc symbol index.
1710
1711    LOCAL_SYMS is a pointer to the swapped in local symbols.
1712
1713    LOCAL_SECTIONS is an array giving the section in the input file
1714    corresponding to the st_shndx field of each local symbol.
1715
1716    The global hash table entry for the global symbols can be found
1717    via elf_sym_hashes (input_bfd).
1718
1719    When generating relocatable output, this function must handle
1720    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
1721    going to be the section symbol corresponding to the output
1722    section, which means that the addend must be adjusted
1723    accordingly.  */
1724
1725 static bfd_boolean
1726 riscv_elf_relocate_section (bfd *output_bfd,
1727                             struct bfd_link_info *info,
1728                             bfd *input_bfd,
1729                             asection *input_section,
1730                             bfd_byte *contents,
1731                             Elf_Internal_Rela *relocs,
1732                             Elf_Internal_Sym *local_syms,
1733                             asection **local_sections)
1734 {
1735   Elf_Internal_Rela *rel;
1736   Elf_Internal_Rela *relend;
1737   riscv_pcrel_relocs pcrel_relocs;
1738   bfd_boolean ret = FALSE;
1739   asection *sreloc = elf_section_data (input_section)->sreloc;
1740   struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info);
1741   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_bfd);
1742   struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
1743   bfd_vma *local_got_offsets = elf_local_got_offsets (input_bfd);
1744   bfd_boolean absolute;
1745
1746   if (!riscv_init_pcrel_relocs (&pcrel_relocs))
1747     return FALSE;
1748
1749   relend = relocs + input_section->reloc_count;
1750   for (rel = relocs; rel < relend; rel++)
1751     {
1752       unsigned long r_symndx;
1753       struct elf_link_hash_entry *h;
1754       Elf_Internal_Sym *sym;
1755       asection *sec;
1756       bfd_vma relocation;
1757       bfd_reloc_status_type r = bfd_reloc_ok;
1758       const char *name;
1759       bfd_vma off, ie_off;
1760       bfd_boolean unresolved_reloc, is_ie = FALSE;
1761       bfd_vma pc = sec_addr (input_section) + rel->r_offset;
1762       int r_type = ELFNN_R_TYPE (rel->r_info), tls_type;
1763       reloc_howto_type *howto = riscv_elf_rtype_to_howto (input_bfd, r_type);
1764       const char *msg = NULL;
1765       bfd_boolean resolved_to_zero;
1766
1767       if (howto == NULL
1768           || r_type == R_RISCV_GNU_VTINHERIT || r_type == R_RISCV_GNU_VTENTRY)
1769         continue;
1770
1771       /* This is a final link.  */
1772       r_symndx = ELFNN_R_SYM (rel->r_info);
1773       h = NULL;
1774       sym = NULL;
1775       sec = NULL;
1776       unresolved_reloc = FALSE;
1777       if (r_symndx < symtab_hdr->sh_info)
1778         {
1779           sym = local_syms + r_symndx;
1780           sec = local_sections[r_symndx];
1781           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1782         }
1783       else
1784         {
1785           bfd_boolean warned, ignored;
1786
1787           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1788                                    r_symndx, symtab_hdr, sym_hashes,
1789                                    h, sec, relocation,
1790                                    unresolved_reloc, warned, ignored);
1791           if (warned)
1792             {
1793               /* To avoid generating warning messages about truncated
1794                  relocations, set the relocation's address to be the same as
1795                  the start of this section.  */
1796               if (input_section->output_section != NULL)
1797                 relocation = input_section->output_section->vma;
1798               else
1799                 relocation = 0;
1800             }
1801         }
1802
1803       if (sec != NULL && discarded_section (sec))
1804         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
1805                                          rel, 1, relend, howto, 0, contents);
1806
1807       if (bfd_link_relocatable (info))
1808         continue;
1809
1810       if (h != NULL)
1811         name = h->root.root.string;
1812       else
1813         {
1814           name = (bfd_elf_string_from_elf_section
1815                   (input_bfd, symtab_hdr->sh_link, sym->st_name));
1816           if (name == NULL || *name == '\0')
1817             name = bfd_section_name (input_bfd, sec);
1818         }
1819
1820       resolved_to_zero = (h != NULL
1821                           && UNDEFWEAK_NO_DYNAMIC_RELOC (info, h));
1822
1823       switch (r_type)
1824         {
1825         case R_RISCV_NONE:
1826         case R_RISCV_RELAX:
1827         case R_RISCV_TPREL_ADD:
1828         case R_RISCV_COPY:
1829         case R_RISCV_JUMP_SLOT:
1830         case R_RISCV_RELATIVE:
1831           /* These require nothing of us at all.  */
1832           continue;
1833
1834         case R_RISCV_HI20:
1835         case R_RISCV_BRANCH:
1836         case R_RISCV_RVC_BRANCH:
1837         case R_RISCV_RVC_LUI:
1838         case R_RISCV_LO12_I:
1839         case R_RISCV_LO12_S:
1840         case R_RISCV_SET6:
1841         case R_RISCV_SET8:
1842         case R_RISCV_SET16:
1843         case R_RISCV_SET32:
1844         case R_RISCV_32_PCREL:
1845         case R_RISCV_DELETE:
1846           /* These require no special handling beyond perform_relocation.  */
1847           break;
1848
1849         case R_RISCV_GOT_HI20:
1850           if (h != NULL)
1851             {
1852               bfd_boolean dyn, pic;
1853
1854               off = h->got.offset;
1855               BFD_ASSERT (off != (bfd_vma) -1);
1856               dyn = elf_hash_table (info)->dynamic_sections_created;
1857               pic = bfd_link_pic (info);
1858
1859               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, pic, h)
1860                   || (pic && SYMBOL_REFERENCES_LOCAL (info, h)))
1861                 {
1862                   /* This is actually a static link, or it is a
1863                      -Bsymbolic link and the symbol is defined
1864                      locally, or the symbol was forced to be local
1865                      because of a version file.  We must initialize
1866                      this entry in the global offset table.  Since the
1867                      offset must always be a multiple of the word size,
1868                      we use the least significant bit to record whether
1869                      we have initialized it already.
1870
1871                      When doing a dynamic link, we create a .rela.got
1872                      relocation entry to initialize the value.  This
1873                      is done in the finish_dynamic_symbol routine.  */
1874                   if ((off & 1) != 0)
1875                     off &= ~1;
1876                   else
1877                     {
1878                       bfd_put_NN (output_bfd, relocation,
1879                                   htab->elf.sgot->contents + off);
1880                       h->got.offset |= 1;
1881                     }
1882                 }
1883               else
1884                 unresolved_reloc = FALSE;
1885             }
1886           else
1887             {
1888               BFD_ASSERT (local_got_offsets != NULL
1889                           && local_got_offsets[r_symndx] != (bfd_vma) -1);
1890
1891               off = local_got_offsets[r_symndx];
1892
1893               /* The offset must always be a multiple of the word size.
1894                  So, we can use the least significant bit to record
1895                  whether we have already processed this entry.  */
1896               if ((off & 1) != 0)
1897                 off &= ~1;
1898               else
1899                 {
1900                   if (bfd_link_pic (info))
1901                     {
1902                       asection *s;
1903                       Elf_Internal_Rela outrel;
1904
1905                       /* We need to generate a R_RISCV_RELATIVE reloc
1906                          for the dynamic linker.  */
1907                       s = htab->elf.srelgot;
1908                       BFD_ASSERT (s != NULL);
1909
1910                       outrel.r_offset = sec_addr (htab->elf.sgot) + off;
1911                       outrel.r_info =
1912                         ELFNN_R_INFO (0, R_RISCV_RELATIVE);
1913                       outrel.r_addend = relocation;
1914                       relocation = 0;
1915                       riscv_elf_append_rela (output_bfd, s, &outrel);
1916                     }
1917
1918                   bfd_put_NN (output_bfd, relocation,
1919                               htab->elf.sgot->contents + off);
1920                   local_got_offsets[r_symndx] |= 1;
1921                 }
1922             }
1923           relocation = sec_addr (htab->elf.sgot) + off;
1924           absolute = riscv_zero_pcrel_hi_reloc (rel,
1925                                                 info,
1926                                                 pc,
1927                                                 relocation,
1928                                                 contents,
1929                                                 howto,
1930                                                 input_bfd);
1931           r_type = ELFNN_R_TYPE (rel->r_info);
1932           howto = riscv_elf_rtype_to_howto (input_bfd, r_type);
1933           if (howto == NULL)
1934             r = bfd_reloc_notsupported;
1935           else if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs, pc,
1936                                                  relocation, absolute))
1937             r = bfd_reloc_overflow;
1938           break;
1939
1940         case R_RISCV_ADD8:
1941         case R_RISCV_ADD16:
1942         case R_RISCV_ADD32:
1943         case R_RISCV_ADD64:
1944           {
1945             bfd_vma old_value = bfd_get (howto->bitsize, input_bfd,
1946                                          contents + rel->r_offset);
1947             relocation = old_value + relocation;
1948           }
1949           break;
1950
1951         case R_RISCV_SUB6:
1952         case R_RISCV_SUB8:
1953         case R_RISCV_SUB16:
1954         case R_RISCV_SUB32:
1955         case R_RISCV_SUB64:
1956           {
1957             bfd_vma old_value = bfd_get (howto->bitsize, input_bfd,
1958                                          contents + rel->r_offset);
1959             relocation = old_value - relocation;
1960           }
1961           break;
1962
1963         case R_RISCV_CALL:
1964           /* Handle a call to an undefined weak function.  This won't be
1965              relaxed, so we have to handle it here.  */
1966           if (h != NULL && h->root.type == bfd_link_hash_undefweak
1967               && h->plt.offset == MINUS_ONE)
1968             {
1969               /* We can use x0 as the base register.  */
1970               bfd_vma insn = bfd_get_32 (input_bfd,
1971                                          contents + rel->r_offset + 4);
1972               insn &= ~(OP_MASK_RS1 << OP_SH_RS1);
1973               bfd_put_32 (input_bfd, insn, contents + rel->r_offset + 4);
1974               /* Set the relocation value so that we get 0 after the pc
1975                  relative adjustment.  */
1976               relocation = sec_addr (input_section) + rel->r_offset;
1977             }
1978           /* Fall through.  */
1979
1980         case R_RISCV_CALL_PLT:
1981         case R_RISCV_JAL:
1982         case R_RISCV_RVC_JUMP:
1983           if (bfd_link_pic (info) && h != NULL && h->plt.offset != MINUS_ONE)
1984             {
1985               /* Refer to the PLT entry.  */
1986               relocation = sec_addr (htab->elf.splt) + h->plt.offset;
1987               unresolved_reloc = FALSE;
1988             }
1989           break;
1990
1991         case R_RISCV_TPREL_HI20:
1992           relocation = tpoff (info, relocation);
1993           break;
1994
1995         case R_RISCV_TPREL_LO12_I:
1996         case R_RISCV_TPREL_LO12_S:
1997           relocation = tpoff (info, relocation);
1998           break;
1999
2000         case R_RISCV_TPREL_I:
2001         case R_RISCV_TPREL_S:
2002           relocation = tpoff (info, relocation);
2003           if (VALID_ITYPE_IMM (relocation + rel->r_addend))
2004             {
2005               /* We can use tp as the base register.  */
2006               bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
2007               insn &= ~(OP_MASK_RS1 << OP_SH_RS1);
2008               insn |= X_TP << OP_SH_RS1;
2009               bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
2010             }
2011           else
2012             r = bfd_reloc_overflow;
2013           break;
2014
2015         case R_RISCV_GPREL_I:
2016         case R_RISCV_GPREL_S:
2017           {
2018             bfd_vma gp = riscv_global_pointer_value (info);
2019             bfd_boolean x0_base = VALID_ITYPE_IMM (relocation + rel->r_addend);
2020             if (x0_base || VALID_ITYPE_IMM (relocation + rel->r_addend - gp))
2021               {
2022                 /* We can use x0 or gp as the base register.  */
2023                 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
2024                 insn &= ~(OP_MASK_RS1 << OP_SH_RS1);
2025                 if (!x0_base)
2026                   {
2027                     rel->r_addend -= gp;
2028                     insn |= X_GP << OP_SH_RS1;
2029                   }
2030                 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
2031               }
2032             else
2033               r = bfd_reloc_overflow;
2034             break;
2035           }
2036
2037         case R_RISCV_PCREL_HI20:
2038           absolute = riscv_zero_pcrel_hi_reloc (rel,
2039                                                 info,
2040                                                 pc,
2041                                                 relocation,
2042                                                 contents,
2043                                                 howto,
2044                                                 input_bfd);
2045           r_type = ELFNN_R_TYPE (rel->r_info);
2046           howto = riscv_elf_rtype_to_howto (input_bfd, r_type);
2047           if (howto == NULL)
2048             r = bfd_reloc_notsupported;
2049           else if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs, pc,
2050                                                  relocation + rel->r_addend,
2051                                                  absolute))
2052             r = bfd_reloc_overflow;
2053           break;
2054
2055         case R_RISCV_PCREL_LO12_I:
2056         case R_RISCV_PCREL_LO12_S:
2057           /* We don't allow section symbols plus addends as the auipc address,
2058              because then riscv_relax_delete_bytes would have to search through
2059              all relocs to update these addends.  This is also ambiguous, as
2060              we do allow offsets to be added to the target address, which are
2061              not to be used to find the auipc address.  */
2062           if ((ELF_ST_TYPE (sym->st_info) == STT_SECTION) && rel->r_addend)
2063             {
2064               r = bfd_reloc_dangerous;
2065               break;
2066             }
2067
2068           if (riscv_record_pcrel_lo_reloc (&pcrel_relocs, input_section, info,
2069                                            howto, rel, relocation, name,
2070                                            contents))
2071             continue;
2072           r = bfd_reloc_overflow;
2073           break;
2074
2075         case R_RISCV_TLS_DTPREL32:
2076         case R_RISCV_TLS_DTPREL64:
2077           relocation = dtpoff (info, relocation);
2078           break;
2079
2080         case R_RISCV_32:
2081         case R_RISCV_64:
2082           if ((input_section->flags & SEC_ALLOC) == 0)
2083             break;
2084
2085           if ((bfd_link_pic (info)
2086                && (h == NULL
2087                    || (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2088                        && !resolved_to_zero)
2089                    || h->root.type != bfd_link_hash_undefweak)
2090                && (! howto->pc_relative
2091                    || !SYMBOL_CALLS_LOCAL (info, h)))
2092               || (!bfd_link_pic (info)
2093                   && h != NULL
2094                   && h->dynindx != -1
2095                   && !h->non_got_ref
2096                   && ((h->def_dynamic
2097                        && !h->def_regular)
2098                       || h->root.type == bfd_link_hash_undefweak
2099                       || h->root.type == bfd_link_hash_undefined)))
2100             {
2101               Elf_Internal_Rela outrel;
2102               bfd_boolean skip_static_relocation, skip_dynamic_relocation;
2103
2104               /* When generating a shared object, these relocations
2105                  are copied into the output file to be resolved at run
2106                  time.  */
2107
2108               outrel.r_offset =
2109                 _bfd_elf_section_offset (output_bfd, info, input_section,
2110                                          rel->r_offset);
2111               skip_static_relocation = outrel.r_offset != (bfd_vma) -2;
2112               skip_dynamic_relocation = outrel.r_offset >= (bfd_vma) -2;
2113               outrel.r_offset += sec_addr (input_section);
2114
2115               if (skip_dynamic_relocation)
2116                 memset (&outrel, 0, sizeof outrel);
2117               else if (h != NULL && h->dynindx != -1
2118                        && !(bfd_link_pic (info)
2119                             && SYMBOLIC_BIND (info, h)
2120                             && h->def_regular))
2121                 {
2122                   outrel.r_info = ELFNN_R_INFO (h->dynindx, r_type);
2123                   outrel.r_addend = rel->r_addend;
2124                 }
2125               else
2126                 {
2127                   outrel.r_info = ELFNN_R_INFO (0, R_RISCV_RELATIVE);
2128                   outrel.r_addend = relocation + rel->r_addend;
2129                 }
2130
2131               riscv_elf_append_rela (output_bfd, sreloc, &outrel);
2132               if (skip_static_relocation)
2133                 continue;
2134             }
2135           break;
2136
2137         case R_RISCV_TLS_GOT_HI20:
2138           is_ie = TRUE;
2139           /* Fall through.  */
2140
2141         case R_RISCV_TLS_GD_HI20:
2142           if (h != NULL)
2143             {
2144               off = h->got.offset;
2145               h->got.offset |= 1;
2146             }
2147           else
2148             {
2149               off = local_got_offsets[r_symndx];
2150               local_got_offsets[r_symndx] |= 1;
2151             }
2152
2153           tls_type = _bfd_riscv_elf_tls_type (input_bfd, h, r_symndx);
2154           BFD_ASSERT (tls_type & (GOT_TLS_IE | GOT_TLS_GD));
2155           /* If this symbol is referenced by both GD and IE TLS, the IE
2156              reference's GOT slot follows the GD reference's slots.  */
2157           ie_off = 0;
2158           if ((tls_type & GOT_TLS_GD) && (tls_type & GOT_TLS_IE))
2159             ie_off = 2 * GOT_ENTRY_SIZE;
2160
2161           if ((off & 1) != 0)
2162             off &= ~1;
2163           else
2164             {
2165               Elf_Internal_Rela outrel;
2166               int indx = 0;
2167               bfd_boolean need_relocs = FALSE;
2168
2169               if (htab->elf.srelgot == NULL)
2170                 abort ();
2171
2172               if (h != NULL)
2173                 {
2174                   bfd_boolean dyn, pic;
2175                   dyn = htab->elf.dynamic_sections_created;
2176                   pic = bfd_link_pic (info);
2177
2178                   if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, pic, h)
2179                       && (!pic || !SYMBOL_REFERENCES_LOCAL (info, h)))
2180                     indx = h->dynindx;
2181                 }
2182
2183               /* The GOT entries have not been initialized yet.  Do it
2184                  now, and emit any relocations.  */
2185               if ((bfd_link_pic (info) || indx != 0)
2186                   && (h == NULL
2187                       || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2188                       || h->root.type != bfd_link_hash_undefweak))
2189                     need_relocs = TRUE;
2190
2191               if (tls_type & GOT_TLS_GD)
2192                 {
2193                   if (need_relocs)
2194                     {
2195                       outrel.r_offset = sec_addr (htab->elf.sgot) + off;
2196                       outrel.r_addend = 0;
2197                       outrel.r_info = ELFNN_R_INFO (indx, R_RISCV_TLS_DTPMODNN);
2198                       bfd_put_NN (output_bfd, 0,
2199                                   htab->elf.sgot->contents + off);
2200                       riscv_elf_append_rela (output_bfd, htab->elf.srelgot, &outrel);
2201                       if (indx == 0)
2202                         {
2203                           BFD_ASSERT (! unresolved_reloc);
2204                           bfd_put_NN (output_bfd,
2205                                       dtpoff (info, relocation),
2206                                       (htab->elf.sgot->contents + off +
2207                                        RISCV_ELF_WORD_BYTES));
2208                         }
2209                       else
2210                         {
2211                           bfd_put_NN (output_bfd, 0,
2212                                       (htab->elf.sgot->contents + off +
2213                                        RISCV_ELF_WORD_BYTES));
2214                           outrel.r_info = ELFNN_R_INFO (indx, R_RISCV_TLS_DTPRELNN);
2215                           outrel.r_offset += RISCV_ELF_WORD_BYTES;
2216                           riscv_elf_append_rela (output_bfd, htab->elf.srelgot, &outrel);
2217                         }
2218                     }
2219                   else
2220                     {
2221                       /* If we are not emitting relocations for a
2222                          general dynamic reference, then we must be in a
2223                          static link or an executable link with the
2224                          symbol binding locally.  Mark it as belonging
2225                          to module 1, the executable.  */
2226                       bfd_put_NN (output_bfd, 1,
2227                                   htab->elf.sgot->contents + off);
2228                       bfd_put_NN (output_bfd,
2229                                   dtpoff (info, relocation),
2230                                   (htab->elf.sgot->contents + off +
2231                                    RISCV_ELF_WORD_BYTES));
2232                    }
2233                 }
2234
2235               if (tls_type & GOT_TLS_IE)
2236                 {
2237                   if (need_relocs)
2238                     {
2239                       bfd_put_NN (output_bfd, 0,
2240                                   htab->elf.sgot->contents + off + ie_off);
2241                       outrel.r_offset = sec_addr (htab->elf.sgot)
2242                                        + off + ie_off;
2243                       outrel.r_addend = 0;
2244                       if (indx == 0)
2245                         outrel.r_addend = tpoff (info, relocation);
2246                       outrel.r_info = ELFNN_R_INFO (indx, R_RISCV_TLS_TPRELNN);
2247                       riscv_elf_append_rela (output_bfd, htab->elf.srelgot, &outrel);
2248                     }
2249                   else
2250                     {
2251                       bfd_put_NN (output_bfd, tpoff (info, relocation),
2252                                   htab->elf.sgot->contents + off + ie_off);
2253                     }
2254                 }
2255             }
2256
2257           BFD_ASSERT (off < (bfd_vma) -2);
2258           relocation = sec_addr (htab->elf.sgot) + off + (is_ie ? ie_off : 0);
2259           if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs, pc,
2260                                             relocation, FALSE))
2261             r = bfd_reloc_overflow;
2262           unresolved_reloc = FALSE;
2263           break;
2264
2265         default:
2266           r = bfd_reloc_notsupported;
2267         }
2268
2269       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2270          because such sections are not SEC_ALLOC and thus ld.so will
2271          not process them.  */
2272       if (unresolved_reloc
2273           && !((input_section->flags & SEC_DEBUGGING) != 0
2274                && h->def_dynamic)
2275           && _bfd_elf_section_offset (output_bfd, info, input_section,
2276                                       rel->r_offset) != (bfd_vma) -1)
2277         {
2278           (*_bfd_error_handler)
2279             (_("%pB(%pA+%#" PRIx64 "): "
2280                "unresolvable %s relocation against symbol `%s'"),
2281              input_bfd,
2282              input_section,
2283              (uint64_t) rel->r_offset,
2284              howto->name,
2285              h->root.root.string);
2286           continue;
2287         }
2288
2289       if (r == bfd_reloc_ok)
2290         r = perform_relocation (howto, rel, relocation, input_section,
2291                                 input_bfd, contents);
2292
2293       switch (r)
2294         {
2295         case bfd_reloc_ok:
2296           continue;
2297
2298         case bfd_reloc_overflow:
2299           info->callbacks->reloc_overflow
2300             (info, (h ? &h->root : NULL), name, howto->name,
2301              (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
2302           break;
2303
2304         case bfd_reloc_undefined:
2305           info->callbacks->undefined_symbol
2306             (info, name, input_bfd, input_section, rel->r_offset,
2307              TRUE);
2308           break;
2309
2310         case bfd_reloc_outofrange:
2311           msg = _("%X%P: internal error: out of range error\n");
2312           break;
2313
2314         case bfd_reloc_notsupported:
2315           msg = _("%X%P: internal error: unsupported relocation error\n");
2316           break;
2317
2318         case bfd_reloc_dangerous:
2319           info->callbacks->reloc_dangerous
2320             (info, "%pcrel_lo section symbol with an addend", input_bfd,
2321              input_section, rel->r_offset);
2322           break;
2323
2324         default:
2325           msg = _("%X%P: internal error: unknown error\n");
2326           break;
2327         }
2328
2329       if (msg)
2330         info->callbacks->einfo (msg);
2331
2332       /* We already reported the error via a callback, so don't try to report
2333          it again by returning false.  That leads to spurious errors.  */
2334       ret = TRUE;
2335       goto out;
2336     }
2337
2338   ret = riscv_resolve_pcrel_lo_relocs (&pcrel_relocs);
2339 out:
2340   riscv_free_pcrel_relocs (&pcrel_relocs);
2341   return ret;
2342 }
2343
2344 /* Finish up dynamic symbol handling.  We set the contents of various
2345    dynamic sections here.  */
2346
2347 static bfd_boolean
2348 riscv_elf_finish_dynamic_symbol (bfd *output_bfd,
2349                                  struct bfd_link_info *info,
2350                                  struct elf_link_hash_entry *h,
2351                                  Elf_Internal_Sym *sym)
2352 {
2353   struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info);
2354   const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
2355
2356   if (h->plt.offset != (bfd_vma) -1)
2357     {
2358       /* We've decided to create a PLT entry for this symbol.  */
2359       bfd_byte *loc;
2360       bfd_vma i, header_address, plt_idx, got_address;
2361       uint32_t plt_entry[PLT_ENTRY_INSNS];
2362       Elf_Internal_Rela rela;
2363
2364       BFD_ASSERT (h->dynindx != -1);
2365
2366       /* Calculate the address of the PLT header.  */
2367       header_address = sec_addr (htab->elf.splt);
2368
2369       /* Calculate the index of the entry.  */
2370       plt_idx = (h->plt.offset - PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
2371
2372       /* Calculate the address of the .got.plt entry.  */
2373       got_address = riscv_elf_got_plt_val (plt_idx, info);
2374
2375       /* Find out where the .plt entry should go.  */
2376       loc = htab->elf.splt->contents + h->plt.offset;
2377
2378       /* Fill in the PLT entry itself.  */
2379       if (! riscv_make_plt_entry (output_bfd, got_address,
2380                                   header_address + h->plt.offset,
2381                                   plt_entry))
2382         return FALSE;
2383
2384       for (i = 0; i < PLT_ENTRY_INSNS; i++)
2385         bfd_put_32 (output_bfd, plt_entry[i], loc + 4*i);
2386
2387       /* Fill in the initial value of the .got.plt entry.  */
2388       loc = htab->elf.sgotplt->contents
2389             + (got_address - sec_addr (htab->elf.sgotplt));
2390       bfd_put_NN (output_bfd, sec_addr (htab->elf.splt), loc);
2391
2392       /* Fill in the entry in the .rela.plt section.  */
2393       rela.r_offset = got_address;
2394       rela.r_addend = 0;
2395       rela.r_info = ELFNN_R_INFO (h->dynindx, R_RISCV_JUMP_SLOT);
2396
2397       loc = htab->elf.srelplt->contents + plt_idx * sizeof (ElfNN_External_Rela);
2398       bed->s->swap_reloca_out (output_bfd, &rela, loc);
2399
2400       if (!h->def_regular)
2401         {
2402           /* Mark the symbol as undefined, rather than as defined in
2403              the .plt section.  Leave the value alone.  */
2404           sym->st_shndx = SHN_UNDEF;
2405           /* If the symbol is weak, we do need to clear the value.
2406              Otherwise, the PLT entry would provide a definition for
2407              the symbol even if the symbol wasn't defined anywhere,
2408              and so the symbol would never be NULL.  */
2409           if (!h->ref_regular_nonweak)
2410             sym->st_value = 0;
2411         }
2412     }
2413
2414   if (h->got.offset != (bfd_vma) -1
2415       && !(riscv_elf_hash_entry (h)->tls_type & (GOT_TLS_GD | GOT_TLS_IE))
2416       && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
2417     {
2418       asection *sgot;
2419       asection *srela;
2420       Elf_Internal_Rela rela;
2421
2422       /* This symbol has an entry in the GOT.  Set it up.  */
2423
2424       sgot = htab->elf.sgot;
2425       srela = htab->elf.srelgot;
2426       BFD_ASSERT (sgot != NULL && srela != NULL);
2427
2428       rela.r_offset = sec_addr (sgot) + (h->got.offset &~ (bfd_vma) 1);
2429
2430       /* If this is a local symbol reference, we just want to emit a RELATIVE
2431          reloc.  This can happen if it is a -Bsymbolic link, or a pie link, or
2432          the symbol was forced to be local because of a version file.
2433          The entry in the global offset table will already have been
2434          initialized in the relocate_section function.  */
2435       if (bfd_link_pic (info)
2436           && SYMBOL_REFERENCES_LOCAL (info, h))
2437         {
2438           BFD_ASSERT((h->got.offset & 1) != 0);
2439           asection *sec = h->root.u.def.section;
2440           rela.r_info = ELFNN_R_INFO (0, R_RISCV_RELATIVE);
2441           rela.r_addend = (h->root.u.def.value
2442                            + sec->output_section->vma
2443                            + sec->output_offset);
2444         }
2445       else
2446         {
2447           BFD_ASSERT((h->got.offset & 1) == 0);
2448           BFD_ASSERT (h->dynindx != -1);
2449           rela.r_info = ELFNN_R_INFO (h->dynindx, R_RISCV_NN);
2450           rela.r_addend = 0;
2451         }
2452
2453       bfd_put_NN (output_bfd, 0,
2454                   sgot->contents + (h->got.offset & ~(bfd_vma) 1));
2455       riscv_elf_append_rela (output_bfd, srela, &rela);
2456     }
2457
2458   if (h->needs_copy)
2459     {
2460       Elf_Internal_Rela rela;
2461       asection *s;
2462
2463       /* This symbols needs a copy reloc.  Set it up.  */
2464       BFD_ASSERT (h->dynindx != -1);
2465
2466       rela.r_offset = sec_addr (h->root.u.def.section) + h->root.u.def.value;
2467       rela.r_info = ELFNN_R_INFO (h->dynindx, R_RISCV_COPY);
2468       rela.r_addend = 0;
2469       if (h->root.u.def.section == htab->elf.sdynrelro)
2470         s = htab->elf.sreldynrelro;
2471       else
2472         s = htab->elf.srelbss;
2473       riscv_elf_append_rela (output_bfd, s, &rela);
2474     }
2475
2476   /* Mark some specially defined symbols as absolute.  */
2477   if (h == htab->elf.hdynamic
2478       || (h == htab->elf.hgot || h == htab->elf.hplt))
2479     sym->st_shndx = SHN_ABS;
2480
2481   return TRUE;
2482 }
2483
2484 /* Finish up the dynamic sections.  */
2485
2486 static bfd_boolean
2487 riscv_finish_dyn (bfd *output_bfd, struct bfd_link_info *info,
2488                   bfd *dynobj, asection *sdyn)
2489 {
2490   struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info);
2491   const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
2492   size_t dynsize = bed->s->sizeof_dyn;
2493   bfd_byte *dyncon, *dynconend;
2494
2495   dynconend = sdyn->contents + sdyn->size;
2496   for (dyncon = sdyn->contents; dyncon < dynconend; dyncon += dynsize)
2497     {
2498       Elf_Internal_Dyn dyn;
2499       asection *s;
2500
2501       bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
2502
2503       switch (dyn.d_tag)
2504         {
2505         case DT_PLTGOT:
2506           s = htab->elf.sgotplt;
2507           dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
2508           break;
2509         case DT_JMPREL:
2510           s = htab->elf.srelplt;
2511           dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
2512           break;
2513         case DT_PLTRELSZ:
2514           s = htab->elf.srelplt;
2515           dyn.d_un.d_val = s->size;
2516           break;
2517         default:
2518           continue;
2519         }
2520
2521       bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
2522     }
2523   return TRUE;
2524 }
2525
2526 static bfd_boolean
2527 riscv_elf_finish_dynamic_sections (bfd *output_bfd,
2528                                    struct bfd_link_info *info)
2529 {
2530   bfd *dynobj;
2531   asection *sdyn;
2532   struct riscv_elf_link_hash_table *htab;
2533
2534   htab = riscv_elf_hash_table (info);
2535   BFD_ASSERT (htab != NULL);
2536   dynobj = htab->elf.dynobj;
2537
2538   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
2539
2540   if (elf_hash_table (info)->dynamic_sections_created)
2541     {
2542       asection *splt;
2543       bfd_boolean ret;
2544
2545       splt = htab->elf.splt;
2546       BFD_ASSERT (splt != NULL && sdyn != NULL);
2547
2548       ret = riscv_finish_dyn (output_bfd, info, dynobj, sdyn);
2549
2550       if (!ret)
2551         return ret;
2552
2553       /* Fill in the head and tail entries in the procedure linkage table.  */
2554       if (splt->size > 0)
2555         {
2556           int i;
2557           uint32_t plt_header[PLT_HEADER_INSNS];
2558           ret = riscv_make_plt_header (output_bfd,
2559                                        sec_addr (htab->elf.sgotplt),
2560                                        sec_addr (splt), plt_header);
2561           if (!ret)
2562             return ret;
2563
2564           for (i = 0; i < PLT_HEADER_INSNS; i++)
2565             bfd_put_32 (output_bfd, plt_header[i], splt->contents + 4*i);
2566
2567           elf_section_data (splt->output_section)->this_hdr.sh_entsize
2568             = PLT_ENTRY_SIZE;
2569         }
2570     }
2571
2572   if (htab->elf.sgotplt)
2573     {
2574       asection *output_section = htab->elf.sgotplt->output_section;
2575
2576       if (bfd_is_abs_section (output_section))
2577         {
2578           (*_bfd_error_handler)
2579             (_("discarded output section: `%pA'"), htab->elf.sgotplt);
2580           return FALSE;
2581         }
2582
2583       if (htab->elf.sgotplt->size > 0)
2584         {
2585           /* Write the first two entries in .got.plt, needed for the dynamic
2586              linker.  */
2587           bfd_put_NN (output_bfd, (bfd_vma) -1, htab->elf.sgotplt->contents);
2588           bfd_put_NN (output_bfd, (bfd_vma) 0,
2589                       htab->elf.sgotplt->contents + GOT_ENTRY_SIZE);
2590         }
2591
2592       elf_section_data (output_section)->this_hdr.sh_entsize = GOT_ENTRY_SIZE;
2593     }
2594
2595   if (htab->elf.sgot)
2596     {
2597       asection *output_section = htab->elf.sgot->output_section;
2598
2599       if (htab->elf.sgot->size > 0)
2600         {
2601           /* Set the first entry in the global offset table to the address of
2602              the dynamic section.  */
2603           bfd_vma val = sdyn ? sec_addr (sdyn) : 0;
2604           bfd_put_NN (output_bfd, val, htab->elf.sgot->contents);
2605         }
2606
2607       elf_section_data (output_section)->this_hdr.sh_entsize = GOT_ENTRY_SIZE;
2608     }
2609
2610   return TRUE;
2611 }
2612
2613 /* Return address for Ith PLT stub in section PLT, for relocation REL
2614    or (bfd_vma) -1 if it should not be included.  */
2615
2616 static bfd_vma
2617 riscv_elf_plt_sym_val (bfd_vma i, const asection *plt,
2618                        const arelent *rel ATTRIBUTE_UNUSED)
2619 {
2620   return plt->vma + PLT_HEADER_SIZE + i * PLT_ENTRY_SIZE;
2621 }
2622
2623 static enum elf_reloc_type_class
2624 riscv_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
2625                         const asection *rel_sec ATTRIBUTE_UNUSED,
2626                         const Elf_Internal_Rela *rela)
2627 {
2628   switch (ELFNN_R_TYPE (rela->r_info))
2629     {
2630     case R_RISCV_RELATIVE:
2631       return reloc_class_relative;
2632     case R_RISCV_JUMP_SLOT:
2633       return reloc_class_plt;
2634     case R_RISCV_COPY:
2635       return reloc_class_copy;
2636     default:
2637       return reloc_class_normal;
2638     }
2639 }
2640
2641 /* Given the ELF header flags in FLAGS, it returns a string that describes the
2642    float ABI.  */
2643
2644 static const char *
2645 riscv_float_abi_string (flagword flags)
2646 {
2647   switch (flags & EF_RISCV_FLOAT_ABI)
2648     {
2649     case EF_RISCV_FLOAT_ABI_SOFT:
2650       return "soft-float";
2651       break;
2652     case EF_RISCV_FLOAT_ABI_SINGLE:
2653       return "single-float";
2654       break;
2655     case EF_RISCV_FLOAT_ABI_DOUBLE:
2656       return "double-float";
2657       break;
2658     case EF_RISCV_FLOAT_ABI_QUAD:
2659       return "quad-float";
2660       break;
2661     default:
2662       abort ();
2663     }
2664 }
2665
2666 /* The information of architecture attribute.  */
2667 static riscv_subset_list_t in_subsets;
2668 static riscv_subset_list_t out_subsets;
2669 static riscv_subset_list_t merged_subsets;
2670
2671 /* Predicator for standard extension.  */
2672
2673 static bfd_boolean
2674 riscv_std_ext_p (const char *name)
2675 {
2676   return (strlen (name) == 1) && (name[0] != 'x') && (name[0] != 's');
2677 }
2678
2679 /* Predicator for non-standard extension.  */
2680
2681 static bfd_boolean
2682 riscv_non_std_ext_p (const char *name)
2683 {
2684   return (strlen (name) >= 2) && (name[0] == 'x');
2685 }
2686
2687 /* Predicator for standard supervisor extension.  */
2688
2689 static bfd_boolean
2690 riscv_std_sv_ext_p (const char *name)
2691 {
2692   return (strlen (name) >= 2) && (name[0] == 's') && (name[1] != 'x');
2693 }
2694
2695 /* Predicator for non-standard supervisor extension.  */
2696
2697 static bfd_boolean
2698 riscv_non_std_sv_ext_p (const char *name)
2699 {
2700   return (strlen (name) >= 3) && (name[0] == 's') && (name[1] == 'x');
2701 }
2702
2703 /* Error handler when version mis-match.  */
2704
2705 static void
2706 riscv_version_mismatch (bfd *ibfd,
2707                         struct riscv_subset_t *in,
2708                         struct riscv_subset_t *out)
2709 {
2710   _bfd_error_handler
2711     (_("error: %pB: Mis-matched ISA version for '%s' exetension. "
2712        "%d.%d vs %d.%d"),
2713        ibfd, in->name,
2714        in->major_version, in->minor_version,
2715        out->major_version, out->minor_version);
2716 }
2717
2718 /* Return true if subset is 'i' or 'e'.  */
2719
2720 static bfd_boolean
2721 riscv_i_or_e_p (bfd *ibfd,
2722                 const char *arch,
2723                 struct riscv_subset_t *subset)
2724 {
2725   if ((strcasecmp (subset->name, "e") != 0)
2726       && (strcasecmp (subset->name, "i") != 0))
2727     {
2728       _bfd_error_handler
2729         (_("error: %pB: corrupted ISA string '%s'."
2730            "first letter should be 'i' or 'e' but got '%s'."),
2731            ibfd, arch, subset->name);
2732       return FALSE;
2733     }
2734   return TRUE;
2735 }
2736
2737 /* Merge standard extensions.
2738
2739    Return Value:
2740      Return FALSE if failed to merge.
2741
2742    Arguments:
2743      `bfd`: bfd handler.
2744      `in_arch`: Raw arch string for input object.
2745      `out_arch`: Raw arch string for output object.
2746      `pin`: subset list for input object, and it'll skip all merged subset after
2747             merge.
2748      `pout`: Like `pin`, but for output object.  */
2749
2750 static bfd_boolean
2751 riscv_merge_std_ext (bfd *ibfd,
2752                      const char *in_arch,
2753                      const char *out_arch,
2754                      struct riscv_subset_t **pin,
2755                      struct riscv_subset_t **pout)
2756 {
2757   const char *standard_exts = riscv_supported_std_ext ();
2758   const char *p;
2759   struct riscv_subset_t *in = *pin;
2760   struct riscv_subset_t *out = *pout;
2761
2762   /* First letter should be 'i' or 'e'.  */
2763   if (!riscv_i_or_e_p (ibfd, in_arch, in))
2764     return FALSE;
2765
2766   if (!riscv_i_or_e_p (ibfd, out_arch, out))
2767     return FALSE;
2768
2769   if (in->name[0] != out->name[0])
2770     {
2771       /* TODO: We might allow merge 'i' with 'e'.  */
2772       _bfd_error_handler
2773         (_("error: %pB: Mis-matched ISA string to merge '%s' and '%s'."),
2774          ibfd, in->name, out->name);
2775       return FALSE;
2776     }
2777   else if ((in->major_version != out->major_version) ||
2778            (in->minor_version != out->minor_version))
2779     {
2780       /* TODO: Allow different merge policy.  */
2781       riscv_version_mismatch (ibfd, in, out);
2782       return FALSE;
2783     }
2784   else
2785     riscv_add_subset (&merged_subsets,
2786                       in->name, in->major_version, in->minor_version);
2787
2788   in = in->next;
2789   out = out->next;
2790
2791   /* Handle standard extension first.  */
2792   for (p = standard_exts; *p; ++p)
2793     {
2794       char find_ext[2] = {*p, '\0'};
2795       struct riscv_subset_t *find_in =
2796         riscv_lookup_subset (&in_subsets, find_ext);
2797       struct riscv_subset_t *find_out =
2798         riscv_lookup_subset (&out_subsets, find_ext);
2799
2800       if (find_in == NULL && find_out == NULL)
2801         continue;
2802
2803       /* Check version is same or not.  */
2804       /* TODO: Allow different merge policy.  */
2805       if ((find_in != NULL && find_out != NULL)
2806           && ((find_in->major_version != find_out->major_version)
2807               || (find_in->minor_version != find_out->minor_version)))
2808         {
2809           riscv_version_mismatch (ibfd, in, out);
2810           return FALSE;
2811         }
2812
2813       struct riscv_subset_t *merged = find_in ? find_in : find_out;
2814       riscv_add_subset (&merged_subsets, merged->name,
2815                         merged->major_version, merged->minor_version);
2816     }
2817
2818   /* Skip all standard extensions.  */
2819   while ((in != NULL) && riscv_std_ext_p (in->name)) in = in->next;
2820   while ((out != NULL) && riscv_std_ext_p (out->name)) out = out->next;
2821
2822   *pin = in;
2823   *pout = out;
2824
2825   return TRUE;
2826 }
2827
2828 /* Merge non-standard and supervisor extensions.
2829    Return Value:
2830      Return FALSE if failed to merge.
2831
2832    Arguments:
2833      `bfd`: bfd handler.
2834      `in_arch`: Raw arch string for input object.
2835      `out_arch`: Raw arch string for output object.
2836      `pin`: subset list for input object, and it'll skip all merged subset after
2837             merge.
2838      `pout`: Like `pin`, but for output object. */
2839
2840 static bfd_boolean
2841 riscv_merge_non_std_and_sv_ext (bfd *ibfd,
2842                                 riscv_subset_t **pin,
2843                                 riscv_subset_t **pout,
2844                                 bfd_boolean (*predicate_func) (const char *))
2845 {
2846   riscv_subset_t *in = *pin;
2847   riscv_subset_t *out = *pout;
2848
2849   for (in = *pin; in != NULL && predicate_func (in->name); in = in->next)
2850     riscv_add_subset (&merged_subsets, in->name, in->major_version,
2851                       in->minor_version);
2852
2853   for (out = *pout; out != NULL && predicate_func (out->name); out = out->next)
2854     {
2855       riscv_subset_t *find_ext =
2856         riscv_lookup_subset (&merged_subsets, out->name);
2857       if (find_ext != NULL)
2858         {
2859           /* Check version is same or not. */
2860           /* TODO: Allow different merge policy.  */
2861           if ((find_ext->major_version != out->major_version)
2862               || (find_ext->minor_version != out->minor_version))
2863             {
2864               riscv_version_mismatch (ibfd, find_ext, out);
2865               return FALSE;
2866             }
2867         }
2868       else
2869         riscv_add_subset (&merged_subsets, out->name,
2870                           out->major_version, out->minor_version);
2871     }
2872
2873   *pin = in;
2874   *pout = out;
2875   return TRUE;
2876 }
2877
2878 /* Merge Tag_RISCV_arch attribute.  */
2879
2880 static char *
2881 riscv_merge_arch_attr_info (bfd *ibfd, char *in_arch, char *out_arch)
2882 {
2883   riscv_subset_t *in, *out;
2884   char *merged_arch_str;
2885
2886   unsigned xlen_in, xlen_out;
2887   merged_subsets.head = NULL;
2888   merged_subsets.tail = NULL;
2889
2890   riscv_parse_subset_t rpe_in;
2891   riscv_parse_subset_t rpe_out;
2892
2893   rpe_in.subset_list = &in_subsets;
2894   rpe_in.error_handler = _bfd_error_handler;
2895   rpe_in.xlen = &xlen_in;
2896
2897   rpe_out.subset_list = &out_subsets;
2898   rpe_out.error_handler = _bfd_error_handler;
2899   rpe_out.xlen = &xlen_out;
2900
2901   if (in_arch == NULL && out_arch == NULL)
2902     return NULL;
2903
2904   if (in_arch == NULL && out_arch != NULL)
2905     return out_arch;
2906
2907   if (in_arch != NULL && out_arch == NULL)
2908     return in_arch;
2909
2910   /* Parse subset from arch string.  */
2911   if (!riscv_parse_subset (&rpe_in, in_arch))
2912     return NULL;
2913
2914   if (!riscv_parse_subset (&rpe_out, out_arch))
2915     return NULL;
2916
2917   /* Checking XLEN.  */
2918   if (xlen_out != xlen_in)
2919     {
2920       _bfd_error_handler
2921         (_("error: %pB: ISA string of input (%s) doesn't match "
2922            "output (%s)."), ibfd, in_arch, out_arch);
2923       return NULL;
2924     }
2925
2926   /* Merge subset list.  */
2927   in = in_subsets.head;
2928   out = out_subsets.head;
2929
2930   /* Merge standard extension.  */
2931   if (!riscv_merge_std_ext (ibfd, in_arch, out_arch, &in, &out))
2932     return NULL;
2933   /* Merge non-standard extension.  */
2934   if (!riscv_merge_non_std_and_sv_ext (ibfd, &in, &out, riscv_non_std_ext_p))
2935     return NULL;
2936   /* Merge standard supervisor extension.  */
2937   if (!riscv_merge_non_std_and_sv_ext (ibfd, &in, &out, riscv_std_sv_ext_p))
2938     return NULL;
2939   /* Merge non-standard supervisor extension.  */
2940   if (!riscv_merge_non_std_and_sv_ext (ibfd, &in, &out, riscv_non_std_sv_ext_p))
2941     return NULL;
2942
2943   if (xlen_in != xlen_out)
2944     {
2945       _bfd_error_handler
2946         (_("error: %pB: XLEN of input (%u) doesn't match "
2947            "output (%u)."), ibfd, xlen_in, xlen_out);
2948       return NULL;
2949     }
2950
2951   if (xlen_in != ARCH_SIZE)
2952     {
2953       _bfd_error_handler
2954         (_("error: %pB: Unspported XLEN (%u), you might"
2955            "using wrong emulation."), ibfd, xlen_in);
2956       return NULL;
2957     }
2958
2959   merged_arch_str = riscv_arch_str (ARCH_SIZE, &merged_subsets);
2960
2961   /* Release the subset lists.  */
2962   riscv_release_subset_list (&in_subsets);
2963   riscv_release_subset_list (&out_subsets);
2964   riscv_release_subset_list (&merged_subsets);
2965
2966   return merged_arch_str;
2967 }
2968
2969 /* Merge object attributes from IBFD into output_bfd of INFO.
2970    Raise an error if there are conflicting attributes.  */
2971
2972 static bfd_boolean
2973 riscv_merge_attributes (bfd *ibfd, struct bfd_link_info *info)
2974 {
2975   bfd *obfd = info->output_bfd;
2976   obj_attribute *in_attr;
2977   obj_attribute *out_attr;
2978   bfd_boolean result = TRUE;
2979   const char *sec_name = get_elf_backend_data (ibfd)->obj_attrs_section;
2980   unsigned int i;
2981
2982   /* Skip linker created files.  */
2983   if (ibfd->flags & BFD_LINKER_CREATED)
2984     return TRUE;
2985
2986   /* Skip any input that doesn't have an attribute section.
2987      This enables to link object files without attribute section with
2988      any others.  */
2989   if (bfd_get_section_by_name (ibfd, sec_name) == NULL)
2990     return TRUE;
2991
2992   if (!elf_known_obj_attributes_proc (obfd)[0].i)
2993     {
2994       /* This is the first object.  Copy the attributes.  */
2995       _bfd_elf_copy_obj_attributes (ibfd, obfd);
2996
2997       out_attr = elf_known_obj_attributes_proc (obfd);
2998
2999       /* Use the Tag_null value to indicate the attributes have been
3000          initialized.  */
3001       out_attr[0].i = 1;
3002
3003       return TRUE;
3004     }
3005
3006   in_attr = elf_known_obj_attributes_proc (ibfd);
3007   out_attr = elf_known_obj_attributes_proc (obfd);
3008
3009   for (i = LEAST_KNOWN_OBJ_ATTRIBUTE; i < NUM_KNOWN_OBJ_ATTRIBUTES; i++)
3010     {
3011     switch (i)
3012       {
3013       case Tag_RISCV_arch:
3014         if (!out_attr[Tag_RISCV_arch].s)
3015           out_attr[Tag_RISCV_arch].s = in_attr[Tag_RISCV_arch].s;
3016         else if (in_attr[Tag_RISCV_arch].s
3017                  && out_attr[Tag_RISCV_arch].s)
3018           {
3019             /* Check arch compatible.  */
3020             char *merged_arch =
3021                 riscv_merge_arch_attr_info (ibfd,
3022                                             in_attr[Tag_RISCV_arch].s,
3023                                             out_attr[Tag_RISCV_arch].s);
3024             if (merged_arch == NULL)
3025               {
3026                 result = FALSE;
3027                 out_attr[Tag_RISCV_arch].s = "";
3028               }
3029             else
3030               out_attr[Tag_RISCV_arch].s = merged_arch;
3031           }
3032         break;
3033       case Tag_RISCV_priv_spec:
3034       case Tag_RISCV_priv_spec_minor:
3035       case Tag_RISCV_priv_spec_revision:
3036         if (out_attr[i].i != in_attr[i].i)
3037           {
3038             _bfd_error_handler
3039               (_("error: %pB: conflicting priv spec version "
3040                  "(major/minor/revision)."), ibfd);
3041             result = FALSE;
3042           }
3043         break;
3044       case Tag_RISCV_unaligned_access:
3045         out_attr[i].i |= in_attr[i].i;
3046         break;
3047       case Tag_RISCV_stack_align:
3048         if (out_attr[i].i == 0)
3049           out_attr[i].i = in_attr[i].i;
3050         else if (in_attr[i].i != 0
3051                  && out_attr[i].i != 0
3052                  && out_attr[i].i != in_attr[i].i)
3053           {
3054             _bfd_error_handler
3055               (_("error: %pB use %u-byte stack aligned but the output "
3056                  "use %u-byte stack aligned."),
3057                ibfd, in_attr[i].i, out_attr[i].i);
3058             result = FALSE;
3059           }
3060         break;
3061       default:
3062         result &= _bfd_elf_merge_unknown_attribute_low (ibfd, obfd, i);
3063       }
3064
3065       /* If out_attr was copied from in_attr then it won't have a type yet.  */
3066       if (in_attr[i].type && !out_attr[i].type)
3067         out_attr[i].type = in_attr[i].type;
3068     }
3069
3070   /* Merge Tag_compatibility attributes and any common GNU ones.  */
3071   if (!_bfd_elf_merge_object_attributes (ibfd, info))
3072     return FALSE;
3073
3074   /* Check for any attributes not known on RISC-V.  */
3075   result &= _bfd_elf_merge_unknown_attribute_list (ibfd, obfd);
3076
3077   return result;
3078 }
3079
3080 /* Merge backend specific data from an object file to the output
3081    object file when linking.  */
3082
3083 static bfd_boolean
3084 _bfd_riscv_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
3085 {
3086   bfd *obfd = info->output_bfd;
3087   flagword new_flags = elf_elfheader (ibfd)->e_flags;
3088   flagword old_flags = elf_elfheader (obfd)->e_flags;
3089
3090   if (!is_riscv_elf (ibfd) || !is_riscv_elf (obfd))
3091     return TRUE;
3092
3093   if (strcmp (bfd_get_target (ibfd), bfd_get_target (obfd)) != 0)
3094     {
3095       (*_bfd_error_handler)
3096         (_("%pB: ABI is incompatible with that of the selected emulation:\n"
3097            "  target emulation `%s' does not match `%s'"),
3098          ibfd, bfd_get_target (ibfd), bfd_get_target (obfd));
3099       return FALSE;
3100     }
3101
3102   if (!_bfd_elf_merge_object_attributes (ibfd, info))
3103     return FALSE;
3104
3105   if (!riscv_merge_attributes (ibfd, info))
3106     return FALSE;
3107
3108   if (! elf_flags_init (obfd))
3109     {
3110       elf_flags_init (obfd) = TRUE;
3111       elf_elfheader (obfd)->e_flags = new_flags;
3112       return TRUE;
3113     }
3114
3115   /* Disallow linking different float ABIs.  */
3116   if ((old_flags ^ new_flags) & EF_RISCV_FLOAT_ABI)
3117     {
3118       (*_bfd_error_handler)
3119         (_("%pB: can't link %s modules with %s modules"), ibfd,
3120          riscv_float_abi_string (new_flags),
3121          riscv_float_abi_string (old_flags));
3122       goto fail;
3123     }
3124
3125   /* Disallow linking RVE and non-RVE.  */
3126   if ((old_flags ^ new_flags) & EF_RISCV_RVE)
3127     {
3128       (*_bfd_error_handler)
3129        (_("%pB: can't link RVE with other target"), ibfd);
3130       goto fail;
3131     }
3132
3133   /* Allow linking RVC and non-RVC, and keep the RVC flag.  */
3134   elf_elfheader (obfd)->e_flags |= new_flags & EF_RISCV_RVC;
3135
3136   return TRUE;
3137
3138 fail:
3139   bfd_set_error (bfd_error_bad_value);
3140   return FALSE;
3141 }
3142
3143 /* Delete some bytes from a section while relaxing.  */
3144
3145 static bfd_boolean
3146 riscv_relax_delete_bytes (bfd *abfd, asection *sec, bfd_vma addr, size_t count,
3147                           struct bfd_link_info *link_info)
3148 {
3149   unsigned int i, symcount;
3150   bfd_vma toaddr = sec->size;
3151   struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (abfd);
3152   Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3153   unsigned int sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
3154   struct bfd_elf_section_data *data = elf_section_data (sec);
3155   bfd_byte *contents = data->this_hdr.contents;
3156
3157   /* Actually delete the bytes.  */
3158   sec->size -= count;
3159   memmove (contents + addr, contents + addr + count, toaddr - addr - count);
3160
3161   /* Adjust the location of all of the relocs.  Note that we need not
3162      adjust the addends, since all PC-relative references must be against
3163      symbols, which we will adjust below.  */
3164   for (i = 0; i < sec->reloc_count; i++)
3165     if (data->relocs[i].r_offset > addr && data->relocs[i].r_offset < toaddr)
3166       data->relocs[i].r_offset -= count;
3167
3168   /* Adjust the local symbols defined in this section.  */
3169   for (i = 0; i < symtab_hdr->sh_info; i++)
3170     {
3171       Elf_Internal_Sym *sym = (Elf_Internal_Sym *) symtab_hdr->contents + i;
3172       if (sym->st_shndx == sec_shndx)
3173         {
3174           /* If the symbol is in the range of memory we just moved, we
3175              have to adjust its value.  */
3176           if (sym->st_value > addr && sym->st_value <= toaddr)
3177             sym->st_value -= count;
3178
3179           /* If the symbol *spans* the bytes we just deleted (i.e. its
3180              *end* is in the moved bytes but its *start* isn't), then we
3181              must adjust its size.
3182
3183              This test needs to use the original value of st_value, otherwise
3184              we might accidentally decrease size when deleting bytes right
3185              before the symbol.  But since deleted relocs can't span across
3186              symbols, we can't have both a st_value and a st_size decrease,
3187              so it is simpler to just use an else.  */
3188           else if (sym->st_value <= addr
3189                    && sym->st_value + sym->st_size > addr
3190                    && sym->st_value + sym->st_size <= toaddr)
3191             sym->st_size -= count;
3192         }
3193     }
3194
3195   /* Now adjust the global symbols defined in this section.  */
3196   symcount = ((symtab_hdr->sh_size / sizeof (ElfNN_External_Sym))
3197               - symtab_hdr->sh_info);
3198
3199   for (i = 0; i < symcount; i++)
3200     {
3201       struct elf_link_hash_entry *sym_hash = sym_hashes[i];
3202
3203       /* The '--wrap SYMBOL' option is causing a pain when the object file,
3204          containing the definition of __wrap_SYMBOL, includes a direct
3205          call to SYMBOL as well. Since both __wrap_SYMBOL and SYMBOL reference
3206          the same symbol (which is __wrap_SYMBOL), but still exist as two
3207          different symbols in 'sym_hashes', we don't want to adjust
3208          the global symbol __wrap_SYMBOL twice.  */
3209       /* The same problem occurs with symbols that are versioned_hidden, as
3210          foo becomes an alias for foo@BAR, and hence they need the same
3211          treatment.  */
3212       if (link_info->wrap_hash != NULL
3213           || sym_hash->versioned == versioned_hidden)
3214         {
3215           struct elf_link_hash_entry **cur_sym_hashes;
3216
3217           /* Loop only over the symbols which have already been checked.  */
3218           for (cur_sym_hashes = sym_hashes; cur_sym_hashes < &sym_hashes[i];
3219                cur_sym_hashes++)
3220             {
3221               /* If the current symbol is identical to 'sym_hash', that means
3222                  the symbol was already adjusted (or at least checked).  */
3223               if (*cur_sym_hashes == sym_hash)
3224                 break;
3225             }
3226           /* Don't adjust the symbol again.  */
3227           if (cur_sym_hashes < &sym_hashes[i])
3228             continue;
3229         }
3230
3231       if ((sym_hash->root.type == bfd_link_hash_defined
3232            || sym_hash->root.type == bfd_link_hash_defweak)
3233           && sym_hash->root.u.def.section == sec)
3234         {
3235           /* As above, adjust the value if needed.  */
3236           if (sym_hash->root.u.def.value > addr
3237               && sym_hash->root.u.def.value <= toaddr)
3238             sym_hash->root.u.def.value -= count;
3239
3240           /* As above, adjust the size if needed.  */
3241           else if (sym_hash->root.u.def.value <= addr
3242                    && sym_hash->root.u.def.value + sym_hash->size > addr
3243                    && sym_hash->root.u.def.value + sym_hash->size <= toaddr)
3244             sym_hash->size -= count;
3245         }
3246     }
3247
3248   return TRUE;
3249 }
3250
3251 /* A second format for recording PC-relative hi relocations.  This stores the
3252    information required to relax them to GP-relative addresses.  */
3253
3254 typedef struct riscv_pcgp_hi_reloc riscv_pcgp_hi_reloc;
3255 struct riscv_pcgp_hi_reloc
3256 {
3257   bfd_vma hi_sec_off;
3258   bfd_vma hi_addend;
3259   bfd_vma hi_addr;
3260   unsigned hi_sym;
3261   asection *sym_sec;
3262   riscv_pcgp_hi_reloc *next;
3263 };
3264
3265 typedef struct riscv_pcgp_lo_reloc riscv_pcgp_lo_reloc;
3266 struct riscv_pcgp_lo_reloc
3267 {
3268   bfd_vma hi_sec_off;
3269   riscv_pcgp_lo_reloc *next;
3270 };
3271
3272 typedef struct
3273 {
3274   riscv_pcgp_hi_reloc *hi;
3275   riscv_pcgp_lo_reloc *lo;
3276 } riscv_pcgp_relocs;
3277
3278 /* Initialize the pcgp reloc info in P.  */
3279
3280 static bfd_boolean
3281 riscv_init_pcgp_relocs (riscv_pcgp_relocs *p)
3282 {
3283   p->hi = NULL;
3284   p->lo = NULL;
3285   return TRUE;
3286 }
3287
3288 /* Free the pcgp reloc info in P.  */
3289
3290 static void
3291 riscv_free_pcgp_relocs (riscv_pcgp_relocs *p,
3292                         bfd *abfd ATTRIBUTE_UNUSED,
3293                         asection *sec ATTRIBUTE_UNUSED)
3294 {
3295   riscv_pcgp_hi_reloc *c;
3296   riscv_pcgp_lo_reloc *l;
3297
3298   for (c = p->hi; c != NULL;)
3299     {
3300       riscv_pcgp_hi_reloc *next = c->next;
3301       free (c);
3302       c = next;
3303     }
3304
3305   for (l = p->lo; l != NULL;)
3306     {
3307       riscv_pcgp_lo_reloc *next = l->next;
3308       free (l);
3309       l = next;
3310     }
3311 }
3312
3313 /* Record pcgp hi part reloc info in P, using HI_SEC_OFF as the lookup index.
3314    The HI_ADDEND, HI_ADDR, HI_SYM, and SYM_SEC args contain info required to
3315    relax the corresponding lo part reloc.  */
3316
3317 static bfd_boolean
3318 riscv_record_pcgp_hi_reloc (riscv_pcgp_relocs *p, bfd_vma hi_sec_off,
3319                             bfd_vma hi_addend, bfd_vma hi_addr,
3320                             unsigned hi_sym, asection *sym_sec)
3321 {
3322   riscv_pcgp_hi_reloc *new = bfd_malloc (sizeof(*new));
3323   if (!new)
3324     return FALSE;
3325   new->hi_sec_off = hi_sec_off;
3326   new->hi_addend = hi_addend;
3327   new->hi_addr = hi_addr;
3328   new->hi_sym = hi_sym;
3329   new->sym_sec = sym_sec;
3330   new->next = p->hi;
3331   p->hi = new;
3332   return TRUE;
3333 }
3334
3335 /* Look up hi part pcgp reloc info in P, using HI_SEC_OFF as the lookup index.
3336    This is used by a lo part reloc to find the corresponding hi part reloc.  */
3337
3338 static riscv_pcgp_hi_reloc *
3339 riscv_find_pcgp_hi_reloc(riscv_pcgp_relocs *p, bfd_vma hi_sec_off)
3340 {
3341   riscv_pcgp_hi_reloc *c;
3342
3343   for (c = p->hi; c != NULL; c = c->next)
3344     if (c->hi_sec_off == hi_sec_off)
3345       return c;
3346   return NULL;
3347 }
3348
3349 /* Record pcgp lo part reloc info in P, using HI_SEC_OFF as the lookup info.
3350    This is used to record relocs that can't be relaxed.  */
3351
3352 static bfd_boolean
3353 riscv_record_pcgp_lo_reloc (riscv_pcgp_relocs *p, bfd_vma hi_sec_off)
3354 {
3355   riscv_pcgp_lo_reloc *new = bfd_malloc (sizeof(*new));
3356   if (!new)
3357     return FALSE;
3358   new->hi_sec_off = hi_sec_off;
3359   new->next = p->lo;
3360   p->lo = new;
3361   return TRUE;
3362 }
3363
3364 /* Look up lo part pcgp reloc info in P, using HI_SEC_OFF as the lookup index.
3365    This is used by a hi part reloc to find the corresponding lo part reloc.  */
3366
3367 static bfd_boolean
3368 riscv_find_pcgp_lo_reloc (riscv_pcgp_relocs *p, bfd_vma hi_sec_off)
3369 {
3370   riscv_pcgp_lo_reloc *c;
3371
3372   for (c = p->lo; c != NULL; c = c->next)
3373     if (c->hi_sec_off == hi_sec_off)
3374       return TRUE;
3375   return FALSE;
3376 }
3377
3378 typedef bfd_boolean (*relax_func_t) (bfd *, asection *, asection *,
3379                                      struct bfd_link_info *,
3380                                      Elf_Internal_Rela *,
3381                                      bfd_vma, bfd_vma, bfd_vma, bfd_boolean *,
3382                                      riscv_pcgp_relocs *);
3383
3384 /* Relax AUIPC + JALR into JAL.  */
3385
3386 static bfd_boolean
3387 _bfd_riscv_relax_call (bfd *abfd, asection *sec, asection *sym_sec,
3388                        struct bfd_link_info *link_info,
3389                        Elf_Internal_Rela *rel,
3390                        bfd_vma symval,
3391                        bfd_vma max_alignment,
3392                        bfd_vma reserve_size ATTRIBUTE_UNUSED,
3393                        bfd_boolean *again,
3394                        riscv_pcgp_relocs *pcgp_relocs ATTRIBUTE_UNUSED)
3395 {
3396   bfd_byte *contents = elf_section_data (sec)->this_hdr.contents;
3397   bfd_signed_vma foff = symval - (sec_addr (sec) + rel->r_offset);
3398   bfd_boolean near_zero = (symval + RISCV_IMM_REACH/2) < RISCV_IMM_REACH;
3399   bfd_vma auipc, jalr;
3400   int rd, r_type, len = 4, rvc = elf_elfheader (abfd)->e_flags & EF_RISCV_RVC;
3401
3402   /* If the call crosses section boundaries, an alignment directive could
3403      cause the PC-relative offset to later increase.  */
3404   if (VALID_UJTYPE_IMM (foff) && sym_sec->output_section != sec->output_section)
3405     foff += (foff < 0 ? -max_alignment : max_alignment);
3406
3407   /* See if this function call can be shortened.  */
3408   if (!VALID_UJTYPE_IMM (foff) && !(!bfd_link_pic (link_info) && near_zero))
3409     return TRUE;
3410
3411   /* Shorten the function call.  */
3412   BFD_ASSERT (rel->r_offset + 8 <= sec->size);
3413
3414   auipc = bfd_get_32 (abfd, contents + rel->r_offset);
3415   jalr = bfd_get_32 (abfd, contents + rel->r_offset + 4);
3416   rd = (jalr >> OP_SH_RD) & OP_MASK_RD;
3417   rvc = rvc && VALID_RVC_J_IMM (foff) && ARCH_SIZE == 32;
3418
3419   if (rvc && (rd == 0 || rd == X_RA))
3420     {
3421       /* Relax to C.J[AL] rd, addr.  */
3422       r_type = R_RISCV_RVC_JUMP;
3423       auipc = rd == 0 ? MATCH_C_J : MATCH_C_JAL;
3424       len = 2;
3425     }
3426   else if (VALID_UJTYPE_IMM (foff))
3427     {
3428       /* Relax to JAL rd, addr.  */
3429       r_type = R_RISCV_JAL;
3430       auipc = MATCH_JAL | (rd << OP_SH_RD);
3431     }
3432   else /* near_zero */
3433     {
3434       /* Relax to JALR rd, x0, addr.  */
3435       r_type = R_RISCV_LO12_I;
3436       auipc = MATCH_JALR | (rd << OP_SH_RD);
3437     }
3438
3439   /* Replace the R_RISCV_CALL reloc.  */
3440   rel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info), r_type);
3441   /* Replace the AUIPC.  */
3442   bfd_put (8 * len, abfd, auipc, contents + rel->r_offset);
3443
3444   /* Delete unnecessary JALR.  */
3445   *again = TRUE;
3446   return riscv_relax_delete_bytes (abfd, sec, rel->r_offset + len, 8 - len,
3447                                    link_info);
3448 }
3449
3450 /* Traverse all output sections and return the max alignment.  */
3451
3452 static bfd_vma
3453 _bfd_riscv_get_max_alignment (asection *sec)
3454 {
3455   unsigned int max_alignment_power = 0;
3456   asection *o;
3457
3458   for (o = sec->output_section->owner->sections; o != NULL; o = o->next)
3459     {
3460       if (o->alignment_power > max_alignment_power)
3461         max_alignment_power = o->alignment_power;
3462     }
3463
3464   return (bfd_vma) 1 << max_alignment_power;
3465 }
3466
3467 /* Relax non-PIC global variable references.  */
3468
3469 static bfd_boolean
3470 _bfd_riscv_relax_lui (bfd *abfd,
3471                       asection *sec,
3472                       asection *sym_sec,
3473                       struct bfd_link_info *link_info,
3474                       Elf_Internal_Rela *rel,
3475                       bfd_vma symval,
3476                       bfd_vma max_alignment,
3477                       bfd_vma reserve_size,
3478                       bfd_boolean *again,
3479                       riscv_pcgp_relocs *pcgp_relocs ATTRIBUTE_UNUSED)
3480 {
3481   bfd_byte *contents = elf_section_data (sec)->this_hdr.contents;
3482   bfd_vma gp = riscv_global_pointer_value (link_info);
3483   int use_rvc = elf_elfheader (abfd)->e_flags & EF_RISCV_RVC;
3484
3485   /* Mergeable symbols and code might later move out of range.  */
3486   if (sym_sec->flags & (SEC_MERGE | SEC_CODE))
3487     return TRUE;
3488
3489   BFD_ASSERT (rel->r_offset + 4 <= sec->size);
3490
3491   if (gp)
3492     {
3493       /* If gp and the symbol are in the same output section, then
3494          consider only that section's alignment.  */
3495       struct bfd_link_hash_entry *h =
3496         bfd_link_hash_lookup (link_info->hash, RISCV_GP_SYMBOL, FALSE, FALSE,
3497                               TRUE);
3498       if (h->u.def.section->output_section == sym_sec->output_section)
3499         max_alignment = (bfd_vma) 1 << sym_sec->output_section->alignment_power;
3500     }
3501
3502   /* Is the reference in range of x0 or gp?
3503      Valid gp range conservatively because of alignment issue.  */
3504   if (VALID_ITYPE_IMM (symval)
3505       || (symval >= gp
3506           && VALID_ITYPE_IMM (symval - gp + max_alignment + reserve_size))
3507       || (symval < gp
3508           && VALID_ITYPE_IMM (symval - gp - max_alignment - reserve_size)))
3509     {
3510       unsigned sym = ELFNN_R_SYM (rel->r_info);
3511       switch (ELFNN_R_TYPE (rel->r_info))
3512         {
3513         case R_RISCV_LO12_I:
3514           rel->r_info = ELFNN_R_INFO (sym, R_RISCV_GPREL_I);
3515           return TRUE;
3516
3517         case R_RISCV_LO12_S:
3518           rel->r_info = ELFNN_R_INFO (sym, R_RISCV_GPREL_S);
3519           return TRUE;
3520
3521         case R_RISCV_HI20:
3522           /* We can delete the unnecessary LUI and reloc.  */
3523           rel->r_info = ELFNN_R_INFO (0, R_RISCV_NONE);
3524           *again = TRUE;
3525           return riscv_relax_delete_bytes (abfd, sec, rel->r_offset, 4,
3526                                            link_info);
3527
3528         default:
3529           abort ();
3530         }
3531     }
3532
3533   /* Can we relax LUI to C.LUI?  Alignment might move the section forward;
3534      account for this assuming page alignment at worst.  */
3535   if (use_rvc
3536       && ELFNN_R_TYPE (rel->r_info) == R_RISCV_HI20
3537       && VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (symval))
3538       && VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (symval + ELF_MAXPAGESIZE)))
3539     {
3540       /* Replace LUI with C.LUI if legal (i.e., rd != x0 and rd != x2/sp).  */
3541       bfd_vma lui = bfd_get_32 (abfd, contents + rel->r_offset);
3542       unsigned rd = ((unsigned)lui >> OP_SH_RD) & OP_MASK_RD;
3543       if (rd == 0 || rd == X_SP)
3544         return TRUE;
3545
3546       lui = (lui & (OP_MASK_RD << OP_SH_RD)) | MATCH_C_LUI;
3547       bfd_put_32 (abfd, lui, contents + rel->r_offset);
3548
3549       /* Replace the R_RISCV_HI20 reloc.  */
3550       rel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info), R_RISCV_RVC_LUI);
3551
3552       *again = TRUE;
3553       return riscv_relax_delete_bytes (abfd, sec, rel->r_offset + 2, 2,
3554                                        link_info);
3555     }
3556
3557   return TRUE;
3558 }
3559
3560 /* Relax non-PIC TLS references.  */
3561
3562 static bfd_boolean
3563 _bfd_riscv_relax_tls_le (bfd *abfd,
3564                          asection *sec,
3565                          asection *sym_sec ATTRIBUTE_UNUSED,
3566                          struct bfd_link_info *link_info,
3567                          Elf_Internal_Rela *rel,
3568                          bfd_vma symval,
3569                          bfd_vma max_alignment ATTRIBUTE_UNUSED,
3570                          bfd_vma reserve_size ATTRIBUTE_UNUSED,
3571                          bfd_boolean *again,
3572                          riscv_pcgp_relocs *prcel_relocs ATTRIBUTE_UNUSED)
3573 {
3574   /* See if this symbol is in range of tp.  */
3575   if (RISCV_CONST_HIGH_PART (tpoff (link_info, symval)) != 0)
3576     return TRUE;
3577
3578   BFD_ASSERT (rel->r_offset + 4 <= sec->size);
3579   switch (ELFNN_R_TYPE (rel->r_info))
3580     {
3581     case R_RISCV_TPREL_LO12_I:
3582       rel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info), R_RISCV_TPREL_I);
3583       return TRUE;
3584
3585     case R_RISCV_TPREL_LO12_S:
3586       rel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info), R_RISCV_TPREL_S);
3587       return TRUE;
3588
3589     case R_RISCV_TPREL_HI20:
3590     case R_RISCV_TPREL_ADD:
3591       /* We can delete the unnecessary instruction and reloc.  */
3592       rel->r_info = ELFNN_R_INFO (0, R_RISCV_NONE);
3593       *again = TRUE;
3594       return riscv_relax_delete_bytes (abfd, sec, rel->r_offset, 4, link_info);
3595
3596     default:
3597       abort ();
3598     }
3599 }
3600
3601 /* Implement R_RISCV_ALIGN by deleting excess alignment NOPs.  */
3602
3603 static bfd_boolean
3604 _bfd_riscv_relax_align (bfd *abfd, asection *sec,
3605                         asection *sym_sec,
3606                         struct bfd_link_info *link_info,
3607                         Elf_Internal_Rela *rel,
3608                         bfd_vma symval,
3609                         bfd_vma max_alignment ATTRIBUTE_UNUSED,
3610                         bfd_vma reserve_size ATTRIBUTE_UNUSED,
3611                         bfd_boolean *again ATTRIBUTE_UNUSED,
3612                         riscv_pcgp_relocs *pcrel_relocs ATTRIBUTE_UNUSED)
3613 {
3614   bfd_byte *contents = elf_section_data (sec)->this_hdr.contents;
3615   bfd_vma alignment = 1, pos;
3616   while (alignment <= rel->r_addend)
3617     alignment *= 2;
3618
3619   symval -= rel->r_addend;
3620   bfd_vma aligned_addr = ((symval - 1) & ~(alignment - 1)) + alignment;
3621   bfd_vma nop_bytes = aligned_addr - symval;
3622
3623   /* Once we've handled an R_RISCV_ALIGN, we can't relax anything else.  */
3624   sec->sec_flg0 = TRUE;
3625
3626   /* Make sure there are enough NOPs to actually achieve the alignment.  */
3627   if (rel->r_addend < nop_bytes)
3628     {
3629       _bfd_error_handler
3630         (_("%pB(%pA+%#" PRIx64 "): %" PRId64 " bytes required for alignment "
3631            "to %" PRId64 "-byte boundary, but only %" PRId64 " present"),
3632          abfd, sym_sec, (uint64_t) rel->r_offset,
3633          (int64_t) nop_bytes, (int64_t) alignment, (int64_t) rel->r_addend);
3634       bfd_set_error (bfd_error_bad_value);
3635       return FALSE;
3636     }
3637
3638   /* Delete the reloc.  */
3639   rel->r_info = ELFNN_R_INFO (0, R_RISCV_NONE);
3640
3641   /* If the number of NOPs is already correct, there's nothing to do.  */
3642   if (nop_bytes == rel->r_addend)
3643     return TRUE;
3644
3645   /* Write as many RISC-V NOPs as we need.  */
3646   for (pos = 0; pos < (nop_bytes & -4); pos += 4)
3647     bfd_put_32 (abfd, RISCV_NOP, contents + rel->r_offset + pos);
3648
3649   /* Write a final RVC NOP if need be.  */
3650   if (nop_bytes % 4 != 0)
3651     bfd_put_16 (abfd, RVC_NOP, contents + rel->r_offset + pos);
3652
3653   /* Delete the excess bytes.  */
3654   return riscv_relax_delete_bytes (abfd, sec, rel->r_offset + nop_bytes,
3655                                    rel->r_addend - nop_bytes, link_info);
3656 }
3657
3658 /* Relax PC-relative references to GP-relative references.  */
3659
3660 static bfd_boolean
3661 _bfd_riscv_relax_pc  (bfd *abfd ATTRIBUTE_UNUSED,
3662                       asection *sec,
3663                       asection *sym_sec,
3664                       struct bfd_link_info *link_info,
3665                       Elf_Internal_Rela *rel,
3666                       bfd_vma symval,
3667                       bfd_vma max_alignment,
3668                       bfd_vma reserve_size,
3669                       bfd_boolean *again ATTRIBUTE_UNUSED,
3670                       riscv_pcgp_relocs *pcgp_relocs)
3671 {
3672   bfd_vma gp = riscv_global_pointer_value (link_info);
3673
3674   BFD_ASSERT (rel->r_offset + 4 <= sec->size);
3675
3676   /* Chain the _LO relocs to their cooresponding _HI reloc to compute the
3677    * actual target address.  */
3678   riscv_pcgp_hi_reloc hi_reloc;
3679   memset (&hi_reloc, 0, sizeof (hi_reloc));
3680   switch (ELFNN_R_TYPE (rel->r_info))
3681     {
3682     case R_RISCV_PCREL_LO12_I:
3683     case R_RISCV_PCREL_LO12_S:
3684       {
3685         /* If the %lo has an addend, it isn't for the label pointing at the
3686            hi part instruction, but rather for the symbol pointed at by the
3687            hi part instruction.  So we must subtract it here for the lookup.
3688            It is still used below in the final symbol address.  */
3689         bfd_vma hi_sec_off = symval - sec_addr (sym_sec) - rel->r_addend;
3690         riscv_pcgp_hi_reloc *hi = riscv_find_pcgp_hi_reloc (pcgp_relocs,
3691                                                             hi_sec_off);
3692         if (hi == NULL)
3693           {
3694             riscv_record_pcgp_lo_reloc (pcgp_relocs, hi_sec_off);
3695             return TRUE;
3696           }
3697
3698         hi_reloc = *hi;
3699         symval = hi_reloc.hi_addr;
3700         sym_sec = hi_reloc.sym_sec;
3701       }
3702       break;
3703
3704     case R_RISCV_PCREL_HI20:
3705       /* Mergeable symbols and code might later move out of range.  */
3706       if (sym_sec->flags & (SEC_MERGE | SEC_CODE))
3707         return TRUE;
3708
3709       /* If the cooresponding lo relocation has already been seen then it's not
3710        * safe to relax this relocation.  */
3711       if (riscv_find_pcgp_lo_reloc (pcgp_relocs, rel->r_offset))
3712         return TRUE;
3713
3714       break;
3715
3716     default:
3717       abort ();
3718     }
3719
3720   if (gp)
3721     {
3722       /* If gp and the symbol are in the same output section, then
3723          consider only that section's alignment.  */
3724       struct bfd_link_hash_entry *h =
3725         bfd_link_hash_lookup (link_info->hash, RISCV_GP_SYMBOL, FALSE, FALSE, TRUE);
3726       if (h->u.def.section->output_section == sym_sec->output_section)
3727         max_alignment = (bfd_vma) 1 << sym_sec->output_section->alignment_power;
3728     }
3729
3730   /* Is the reference in range of x0 or gp?
3731      Valid gp range conservatively because of alignment issue.  */
3732   if (VALID_ITYPE_IMM (symval)
3733       || (symval >= gp
3734           && VALID_ITYPE_IMM (symval - gp + max_alignment + reserve_size))
3735       || (symval < gp
3736           && VALID_ITYPE_IMM (symval - gp - max_alignment - reserve_size)))
3737     {
3738       unsigned sym = hi_reloc.hi_sym;
3739       switch (ELFNN_R_TYPE (rel->r_info))
3740         {
3741         case R_RISCV_PCREL_LO12_I:
3742           rel->r_info = ELFNN_R_INFO (sym, R_RISCV_GPREL_I);
3743           rel->r_addend += hi_reloc.hi_addend;
3744           return TRUE;
3745
3746         case R_RISCV_PCREL_LO12_S:
3747           rel->r_info = ELFNN_R_INFO (sym, R_RISCV_GPREL_S);
3748           rel->r_addend += hi_reloc.hi_addend;
3749           return TRUE;
3750
3751         case R_RISCV_PCREL_HI20:
3752           riscv_record_pcgp_hi_reloc (pcgp_relocs,
3753                                       rel->r_offset,
3754                                       rel->r_addend,
3755                                       symval,
3756                                       ELFNN_R_SYM(rel->r_info),
3757                                       sym_sec);
3758           /* We can delete the unnecessary AUIPC and reloc.  */
3759           rel->r_info = ELFNN_R_INFO (0, R_RISCV_DELETE);
3760           rel->r_addend = 4;
3761           return TRUE;
3762
3763         default:
3764           abort ();
3765         }
3766     }
3767
3768   return TRUE;
3769 }
3770
3771 /* Relax PC-relative references to GP-relative references.  */
3772
3773 static bfd_boolean
3774 _bfd_riscv_relax_delete (bfd *abfd,
3775                          asection *sec,
3776                          asection *sym_sec ATTRIBUTE_UNUSED,
3777                          struct bfd_link_info *link_info,
3778                          Elf_Internal_Rela *rel,
3779                          bfd_vma symval ATTRIBUTE_UNUSED,
3780                          bfd_vma max_alignment ATTRIBUTE_UNUSED,
3781                          bfd_vma reserve_size ATTRIBUTE_UNUSED,
3782                          bfd_boolean *again ATTRIBUTE_UNUSED,
3783                          riscv_pcgp_relocs *pcgp_relocs ATTRIBUTE_UNUSED)
3784 {
3785   if (!riscv_relax_delete_bytes(abfd, sec, rel->r_offset, rel->r_addend,
3786                                 link_info))
3787     return FALSE;
3788   rel->r_info = ELFNN_R_INFO(0, R_RISCV_NONE);
3789   return TRUE;
3790 }
3791
3792 /* Relax a section.  Pass 0 shortens code sequences unless disabled.  Pass 1
3793    deletes the bytes that pass 0 made obselete.  Pass 2, which cannot be
3794    disabled, handles code alignment directives.  */
3795
3796 static bfd_boolean
3797 _bfd_riscv_relax_section (bfd *abfd, asection *sec,
3798                           struct bfd_link_info *info,
3799                           bfd_boolean *again)
3800 {
3801   Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (abfd);
3802   struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info);
3803   struct bfd_elf_section_data *data = elf_section_data (sec);
3804   Elf_Internal_Rela *relocs;
3805   bfd_boolean ret = FALSE;
3806   unsigned int i;
3807   bfd_vma max_alignment, reserve_size = 0;
3808   riscv_pcgp_relocs pcgp_relocs;
3809
3810   *again = FALSE;
3811
3812   if (bfd_link_relocatable (info)
3813       || sec->sec_flg0
3814       || (sec->flags & SEC_RELOC) == 0
3815       || sec->reloc_count == 0
3816       || (info->disable_target_specific_optimizations
3817           && info->relax_pass == 0))
3818     return TRUE;
3819
3820   riscv_init_pcgp_relocs (&pcgp_relocs);
3821
3822   /* Read this BFD's relocs if we haven't done so already.  */
3823   if (data->relocs)
3824     relocs = data->relocs;
3825   else if (!(relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
3826                                                  info->keep_memory)))
3827     goto fail;
3828
3829   if (htab)
3830     {
3831       max_alignment = htab->max_alignment;
3832       if (max_alignment == (bfd_vma) -1)
3833         {
3834           max_alignment = _bfd_riscv_get_max_alignment (sec);
3835           htab->max_alignment = max_alignment;
3836         }
3837     }
3838   else
3839     max_alignment = _bfd_riscv_get_max_alignment (sec);
3840
3841   /* Examine and consider relaxing each reloc.  */
3842   for (i = 0; i < sec->reloc_count; i++)
3843     {
3844       asection *sym_sec;
3845       Elf_Internal_Rela *rel = relocs + i;
3846       relax_func_t relax_func;
3847       int type = ELFNN_R_TYPE (rel->r_info);
3848       bfd_vma symval;
3849
3850       relax_func = NULL;
3851       if (info->relax_pass == 0)
3852         {
3853           if (type == R_RISCV_CALL || type == R_RISCV_CALL_PLT)
3854             relax_func = _bfd_riscv_relax_call;
3855           else if (type == R_RISCV_HI20
3856                    || type == R_RISCV_LO12_I
3857                    || type == R_RISCV_LO12_S)
3858             relax_func = _bfd_riscv_relax_lui;
3859           else if (!bfd_link_pic(info)
3860                    && (type == R_RISCV_PCREL_HI20
3861                    || type == R_RISCV_PCREL_LO12_I
3862                    || type == R_RISCV_PCREL_LO12_S))
3863             relax_func = _bfd_riscv_relax_pc;
3864           else if (type == R_RISCV_TPREL_HI20
3865                    || type == R_RISCV_TPREL_ADD
3866                    || type == R_RISCV_TPREL_LO12_I
3867                    || type == R_RISCV_TPREL_LO12_S)
3868             relax_func = _bfd_riscv_relax_tls_le;
3869           else
3870             continue;
3871
3872           /* Only relax this reloc if it is paired with R_RISCV_RELAX.  */
3873           if (i == sec->reloc_count - 1
3874               || ELFNN_R_TYPE ((rel + 1)->r_info) != R_RISCV_RELAX
3875               || rel->r_offset != (rel + 1)->r_offset)
3876             continue;
3877
3878           /* Skip over the R_RISCV_RELAX.  */
3879           i++;
3880         }
3881       else if (info->relax_pass == 1 && type == R_RISCV_DELETE)
3882         relax_func = _bfd_riscv_relax_delete;
3883       else if (info->relax_pass == 2 && type == R_RISCV_ALIGN)
3884         relax_func = _bfd_riscv_relax_align;
3885       else
3886         continue;
3887
3888       data->relocs = relocs;
3889
3890       /* Read this BFD's contents if we haven't done so already.  */
3891       if (!data->this_hdr.contents
3892           && !bfd_malloc_and_get_section (abfd, sec, &data->this_hdr.contents))
3893         goto fail;
3894
3895       /* Read this BFD's symbols if we haven't done so already.  */
3896       if (symtab_hdr->sh_info != 0
3897           && !symtab_hdr->contents
3898           && !(symtab_hdr->contents =
3899                (unsigned char *) bfd_elf_get_elf_syms (abfd, symtab_hdr,
3900                                                        symtab_hdr->sh_info,
3901                                                        0, NULL, NULL, NULL)))
3902         goto fail;
3903
3904       /* Get the value of the symbol referred to by the reloc.  */
3905       if (ELFNN_R_SYM (rel->r_info) < symtab_hdr->sh_info)
3906         {
3907           /* A local symbol.  */
3908           Elf_Internal_Sym *isym = ((Elf_Internal_Sym *) symtab_hdr->contents
3909                                     + ELFNN_R_SYM (rel->r_info));
3910           reserve_size = (isym->st_size - rel->r_addend) > isym->st_size
3911             ? 0 : isym->st_size - rel->r_addend;
3912
3913           if (isym->st_shndx == SHN_UNDEF)
3914             sym_sec = sec, symval = sec_addr (sec) + rel->r_offset;
3915           else
3916             {
3917               BFD_ASSERT (isym->st_shndx < elf_numsections (abfd));
3918               sym_sec = elf_elfsections (abfd)[isym->st_shndx]->bfd_section;
3919 #if 0
3920               /* The purpose of this code is unknown.  It breaks linker scripts
3921                  for embedded development that place sections at address zero.
3922                  This code is believed to be unnecessary.  Disabling it but not
3923                  yet removing it, in case something breaks.  */
3924               if (sec_addr (sym_sec) == 0)
3925                 continue;
3926 #endif
3927               symval = sec_addr (sym_sec) + isym->st_value;
3928             }
3929         }
3930       else
3931         {
3932           unsigned long indx;
3933           struct elf_link_hash_entry *h;
3934
3935           indx = ELFNN_R_SYM (rel->r_info) - symtab_hdr->sh_info;
3936           h = elf_sym_hashes (abfd)[indx];
3937
3938           while (h->root.type == bfd_link_hash_indirect
3939                  || h->root.type == bfd_link_hash_warning)
3940             h = (struct elf_link_hash_entry *) h->root.u.i.link;
3941
3942           if (h->plt.offset != MINUS_ONE)
3943             symval = sec_addr (htab->elf.splt) + h->plt.offset;
3944           else if (h->root.u.def.section->output_section == NULL
3945                    || (h->root.type != bfd_link_hash_defined
3946                        && h->root.type != bfd_link_hash_defweak))
3947             continue;
3948           else
3949             symval = sec_addr (h->root.u.def.section) + h->root.u.def.value;
3950
3951           if (h->type != STT_FUNC)
3952             reserve_size =
3953               (h->size - rel->r_addend) > h->size ? 0 : h->size - rel->r_addend;
3954           sym_sec = h->root.u.def.section;
3955         }
3956
3957       symval += rel->r_addend;
3958
3959       if (!relax_func (abfd, sec, sym_sec, info, rel, symval,
3960                        max_alignment, reserve_size, again,
3961                        &pcgp_relocs))
3962         goto fail;
3963     }
3964
3965   ret = TRUE;
3966
3967 fail:
3968   if (relocs != data->relocs)
3969     free (relocs);
3970   riscv_free_pcgp_relocs(&pcgp_relocs, abfd, sec);
3971
3972   return ret;
3973 }
3974
3975 #if ARCH_SIZE == 32
3976 # define PRSTATUS_SIZE                  0 /* FIXME */
3977 # define PRSTATUS_OFFSET_PR_CURSIG      12
3978 # define PRSTATUS_OFFSET_PR_PID         24
3979 # define PRSTATUS_OFFSET_PR_REG         72
3980 # define ELF_GREGSET_T_SIZE             128
3981 # define PRPSINFO_SIZE                  128
3982 # define PRPSINFO_OFFSET_PR_PID         16
3983 # define PRPSINFO_OFFSET_PR_FNAME       32
3984 # define PRPSINFO_OFFSET_PR_PSARGS      48
3985 #else
3986 # define PRSTATUS_SIZE                  376
3987 # define PRSTATUS_OFFSET_PR_CURSIG      12
3988 # define PRSTATUS_OFFSET_PR_PID         32
3989 # define PRSTATUS_OFFSET_PR_REG         112
3990 # define ELF_GREGSET_T_SIZE             256
3991 # define PRPSINFO_SIZE                  136
3992 # define PRPSINFO_OFFSET_PR_PID         24
3993 # define PRPSINFO_OFFSET_PR_FNAME       40
3994 # define PRPSINFO_OFFSET_PR_PSARGS      56
3995 #endif
3996
3997 /* Support for core dump NOTE sections.  */
3998
3999 static bfd_boolean
4000 riscv_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
4001 {
4002   switch (note->descsz)
4003     {
4004       default:
4005         return FALSE;
4006
4007       case PRSTATUS_SIZE:  /* sizeof(struct elf_prstatus) on Linux/RISC-V.  */
4008         /* pr_cursig */
4009         elf_tdata (abfd)->core->signal
4010           = bfd_get_16 (abfd, note->descdata + PRSTATUS_OFFSET_PR_CURSIG);
4011
4012         /* pr_pid */
4013         elf_tdata (abfd)->core->lwpid
4014           = bfd_get_32 (abfd, note->descdata + PRSTATUS_OFFSET_PR_PID);
4015         break;
4016     }
4017
4018   /* Make a ".reg/999" section.  */
4019   return _bfd_elfcore_make_pseudosection (abfd, ".reg", ELF_GREGSET_T_SIZE,
4020                                           note->descpos + PRSTATUS_OFFSET_PR_REG);
4021 }
4022
4023 static bfd_boolean
4024 riscv_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
4025 {
4026   switch (note->descsz)
4027     {
4028       default:
4029         return FALSE;
4030
4031       case PRPSINFO_SIZE: /* sizeof(struct elf_prpsinfo) on Linux/RISC-V.  */
4032         /* pr_pid */
4033         elf_tdata (abfd)->core->pid
4034           = bfd_get_32 (abfd, note->descdata + PRPSINFO_OFFSET_PR_PID);
4035
4036         /* pr_fname */
4037         elf_tdata (abfd)->core->program = _bfd_elfcore_strndup
4038           (abfd, note->descdata + PRPSINFO_OFFSET_PR_FNAME, 16);
4039
4040         /* pr_psargs */
4041         elf_tdata (abfd)->core->command = _bfd_elfcore_strndup
4042           (abfd, note->descdata + PRPSINFO_OFFSET_PR_PSARGS, 80);
4043         break;
4044     }
4045
4046   /* Note that for some reason, a spurious space is tacked
4047      onto the end of the args in some (at least one anyway)
4048      implementations, so strip it off if it exists.  */
4049
4050   {
4051     char *command = elf_tdata (abfd)->core->command;
4052     int n = strlen (command);
4053
4054     if (0 < n && command[n - 1] == ' ')
4055       command[n - 1] = '\0';
4056   }
4057
4058   return TRUE;
4059 }
4060
4061 /* Set the right mach type.  */
4062 static bfd_boolean
4063 riscv_elf_object_p (bfd *abfd)
4064 {
4065   /* There are only two mach types in RISCV currently.  */
4066   if (strcmp (abfd->xvec->name, "elf32-littleriscv") == 0)
4067     bfd_default_set_arch_mach (abfd, bfd_arch_riscv, bfd_mach_riscv32);
4068   else
4069     bfd_default_set_arch_mach (abfd, bfd_arch_riscv, bfd_mach_riscv64);
4070
4071   return TRUE;
4072 }
4073
4074 /* Determine whether an object attribute tag takes an integer, a
4075    string or both.  */
4076
4077 static int
4078 riscv_elf_obj_attrs_arg_type (int tag)
4079 {
4080   return (tag & 1) != 0 ? ATTR_TYPE_FLAG_STR_VAL : ATTR_TYPE_FLAG_INT_VAL;
4081 }
4082
4083 #define TARGET_LITTLE_SYM               riscv_elfNN_vec
4084 #define TARGET_LITTLE_NAME              "elfNN-littleriscv"
4085
4086 #define elf_backend_reloc_type_class         riscv_reloc_type_class
4087
4088 #define bfd_elfNN_bfd_reloc_name_lookup      riscv_reloc_name_lookup
4089 #define bfd_elfNN_bfd_link_hash_table_create riscv_elf_link_hash_table_create
4090 #define bfd_elfNN_bfd_reloc_type_lookup      riscv_reloc_type_lookup
4091 #define bfd_elfNN_bfd_merge_private_bfd_data \
4092   _bfd_riscv_elf_merge_private_bfd_data
4093
4094 #define elf_backend_copy_indirect_symbol     riscv_elf_copy_indirect_symbol
4095 #define elf_backend_create_dynamic_sections  riscv_elf_create_dynamic_sections
4096 #define elf_backend_check_relocs             riscv_elf_check_relocs
4097 #define elf_backend_adjust_dynamic_symbol    riscv_elf_adjust_dynamic_symbol
4098 #define elf_backend_size_dynamic_sections    riscv_elf_size_dynamic_sections
4099 #define elf_backend_relocate_section         riscv_elf_relocate_section
4100 #define elf_backend_finish_dynamic_symbol    riscv_elf_finish_dynamic_symbol
4101 #define elf_backend_finish_dynamic_sections  riscv_elf_finish_dynamic_sections
4102 #define elf_backend_gc_mark_hook             riscv_elf_gc_mark_hook
4103 #define elf_backend_plt_sym_val              riscv_elf_plt_sym_val
4104 #define elf_backend_grok_prstatus            riscv_elf_grok_prstatus
4105 #define elf_backend_grok_psinfo              riscv_elf_grok_psinfo
4106 #define elf_backend_object_p                 riscv_elf_object_p
4107 #define elf_info_to_howto_rel                NULL
4108 #define elf_info_to_howto                    riscv_info_to_howto_rela
4109 #define bfd_elfNN_bfd_relax_section          _bfd_riscv_relax_section
4110
4111 #define elf_backend_init_index_section       _bfd_elf_init_1_index_section
4112
4113 #define elf_backend_can_gc_sections     1
4114 #define elf_backend_can_refcount        1
4115 #define elf_backend_want_got_plt        1
4116 #define elf_backend_plt_readonly        1
4117 #define elf_backend_plt_alignment       4
4118 #define elf_backend_want_plt_sym        1
4119 #define elf_backend_got_header_size     (ARCH_SIZE / 8)
4120 #define elf_backend_want_dynrelro       1
4121 #define elf_backend_rela_normal         1
4122 #define elf_backend_default_execstack   0
4123
4124 #undef  elf_backend_obj_attrs_vendor
4125 #define elf_backend_obj_attrs_vendor            "riscv"
4126 #undef  elf_backend_obj_attrs_arg_type
4127 #define elf_backend_obj_attrs_arg_type          riscv_elf_obj_attrs_arg_type
4128 #undef  elf_backend_obj_attrs_section_type
4129 #define elf_backend_obj_attrs_section_type      SHT_RISCV_ATTRIBUTES
4130 #undef  elf_backend_obj_attrs_section
4131 #define elf_backend_obj_attrs_section           ".riscv.attributes"
4132
4133 #include "elfNN-target.h"