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