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