1 /* SPARC-specific support for 64-bit ELF
2 Copyright (C) 1993-2020 Free Software Foundation, Inc.
3
4 This file is part of BFD, the Binary File Descriptor library.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
20
21 #include "sysdep.h"
22 #include <limits.h>
23 #include "bfd.h"
24 #include "libbfd.h"
25 #include "elf-bfd.h"
26 #include "elf/sparc.h"
27 #include "opcode/sparc.h"
28 #include "elfxx-sparc.h"
29
30 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
31 #define MINUS_ONE (~ (bfd_vma) 0)
32
33 /* Due to the way how we handle R_SPARC_OLO10, each entry in a SHT_RELA
34 section can represent up to two relocs, we must tell the user to allocate
35 more space. */
36
37 static long
elf64_sparc_get_reloc_upper_bound(bfd * abfd ATTRIBUTE_UNUSED,asection * sec)38 elf64_sparc_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED, asection *sec)
39 {
40 #if SIZEOF_LONG == SIZEOF_INT
41 if (sec->reloc_count >= LONG_MAX / 2 / sizeof (arelent *))
42 {
43 bfd_set_error (bfd_error_file_too_big);
44 return -1;
45 }
46 #endif
47 return (sec->reloc_count * 2 + 1) * sizeof (arelent *);
48 }
49
50 static long
elf64_sparc_get_dynamic_reloc_upper_bound(bfd * abfd)51 elf64_sparc_get_dynamic_reloc_upper_bound (bfd *abfd)
52 {
53 long ret = _bfd_elf_get_dynamic_reloc_upper_bound (abfd);
54 if (ret > LONG_MAX / 2)
55 {
56 bfd_set_error (bfd_error_file_too_big);
57 ret = -1;
58 }
59 else if (ret > 0)
60 ret *= 2;
61 return ret;
62 }
63
64 /* Read relocations for ASECT from REL_HDR. There are RELOC_COUNT of
65 them. We cannot use generic elf routines for this, because R_SPARC_OLO10
66 has secondary addend in ELF64_R_TYPE_DATA. We handle it as two relocations
67 for the same location, R_SPARC_LO10 and R_SPARC_13. */
68
69 static bfd_boolean
elf64_sparc_slurp_one_reloc_table(bfd * abfd,asection * asect,Elf_Internal_Shdr * rel_hdr,asymbol ** symbols,bfd_boolean dynamic)70 elf64_sparc_slurp_one_reloc_table (bfd *abfd, asection *asect,
71 Elf_Internal_Shdr *rel_hdr,
72 asymbol **symbols, bfd_boolean dynamic)
73 {
74 void * allocated = NULL;
75 bfd_byte *native_relocs;
76 arelent *relent;
77 unsigned int i;
78 int entsize;
79 bfd_size_type count;
80 arelent *relents;
81
82 allocated = bfd_malloc (rel_hdr->sh_size);
83 if (allocated == NULL)
84 goto error_return;
85
86 if (bfd_seek (abfd, rel_hdr->sh_offset, SEEK_SET) != 0
87 || bfd_bread (allocated, rel_hdr->sh_size, abfd) != rel_hdr->sh_size)
88 goto error_return;
89
90 native_relocs = (bfd_byte *) allocated;
91
92 relents = asect->relocation + canon_reloc_count (asect);
93
94 entsize = rel_hdr->sh_entsize;
95 BFD_ASSERT (entsize == sizeof (Elf64_External_Rela));
96
97 count = rel_hdr->sh_size / entsize;
98
99 for (i = 0, relent = relents; i < count;
100 i++, relent++, native_relocs += entsize)
101 {
102 Elf_Internal_Rela rela;
103 unsigned int r_type;
104
105 bfd_elf64_swap_reloca_in (abfd, native_relocs, &rela);
106
107 /* The address of an ELF reloc is section relative for an object
108 file, and absolute for an executable file or shared library.
109 The address of a normal BFD reloc is always section relative,
110 and the address of a dynamic reloc is absolute.. */
111 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0 || dynamic)
112 relent->address = rela.r_offset;
113 else
114 relent->address = rela.r_offset - asect->vma;
115
116 if (ELF64_R_SYM (rela.r_info) == STN_UNDEF)
117 relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
118 else if (/* PR 17512: file: 996185f8. */
119 ELF64_R_SYM (rela.r_info) > (dynamic
120 ? bfd_get_dynamic_symcount (abfd)
121 : bfd_get_symcount (abfd)))
122 {
123 _bfd_error_handler
124 /* xgettext:c-format */
125 (_("%pB(%pA): relocation %d has invalid symbol index %ld"),
126 abfd, asect, i, (long) ELF64_R_SYM (rela.r_info));
127 bfd_set_error (bfd_error_bad_value);
128 relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
129 }
130 else
131 {
132 asymbol **ps, *s;
133
134 ps = symbols + ELF64_R_SYM (rela.r_info) - 1;
135 s = *ps;
136
137 /* Canonicalize ELF section symbols. FIXME: Why? */
138 if ((s->flags & BSF_SECTION_SYM) == 0)
139 relent->sym_ptr_ptr = ps;
140 else
141 relent->sym_ptr_ptr = s->section->symbol_ptr_ptr;
142 }
143
144 relent->addend = rela.r_addend;
145
146 r_type = ELF64_R_TYPE_ID (rela.r_info);
147 if (r_type == R_SPARC_OLO10)
148 {
149 relent->howto = _bfd_sparc_elf_info_to_howto_ptr (abfd, R_SPARC_LO10);
150 relent[1].address = relent->address;
151 relent++;
152 relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
153 relent->addend = ELF64_R_TYPE_DATA (rela.r_info);
154 relent->howto = _bfd_sparc_elf_info_to_howto_ptr (abfd, R_SPARC_13);
155 }
156 else
157 {
158 relent->howto = _bfd_sparc_elf_info_to_howto_ptr (abfd, r_type);
159 if (relent->howto == NULL)
160 goto error_return;
161 }
162 }
163
164 canon_reloc_count (asect) += relent - relents;
165
166 if (allocated != NULL)
167 free (allocated);
168
169 return TRUE;
170
171 error_return:
172 if (allocated != NULL)
173 free (allocated);
174 return FALSE;
175 }
176
177 /* Read in and swap the external relocs. */
178
179 static bfd_boolean
elf64_sparc_slurp_reloc_table(bfd * abfd,asection * asect,asymbol ** symbols,bfd_boolean dynamic)180 elf64_sparc_slurp_reloc_table (bfd *abfd, asection *asect,
181 asymbol **symbols, bfd_boolean dynamic)
182 {
183 struct bfd_elf_section_data * const d = elf_section_data (asect);
184 Elf_Internal_Shdr *rel_hdr;
185 Elf_Internal_Shdr *rel_hdr2;
186 bfd_size_type amt;
187
188 if (asect->relocation != NULL)
189 return TRUE;
190
191 if (! dynamic)
192 {
193 if ((asect->flags & SEC_RELOC) == 0
194 || asect->reloc_count == 0)
195 return TRUE;
196
197 rel_hdr = d->rel.hdr;
198 rel_hdr2 = d->rela.hdr;
199
200 BFD_ASSERT ((rel_hdr && asect->rel_filepos == rel_hdr->sh_offset)
201 || (rel_hdr2 && asect->rel_filepos == rel_hdr2->sh_offset));
202 }
203 else
204 {
205 /* Note that ASECT->RELOC_COUNT tends not to be accurate in this
206 case because relocations against this section may use the
207 dynamic symbol table, and in that case bfd_section_from_shdr
208 in elf.c does not update the RELOC_COUNT. */
209 if (asect->size == 0)
210 return TRUE;
211
212 rel_hdr = &d->this_hdr;
213 asect->reloc_count = NUM_SHDR_ENTRIES (rel_hdr);
214 rel_hdr2 = NULL;
215 }
216
217 amt = asect->reloc_count;
218 amt *= 2 * sizeof (arelent);
219 asect->relocation = (arelent *) bfd_alloc (abfd, amt);
220 if (asect->relocation == NULL)
221 return FALSE;
222
223 /* The elf64_sparc_slurp_one_reloc_table routine increments
224 canon_reloc_count. */
225 canon_reloc_count (asect) = 0;
226
227 if (rel_hdr
228 && !elf64_sparc_slurp_one_reloc_table (abfd, asect, rel_hdr, symbols,
229 dynamic))
230 return FALSE;
231
232 if (rel_hdr2
233 && !elf64_sparc_slurp_one_reloc_table (abfd, asect, rel_hdr2, symbols,
234 dynamic))
235 return FALSE;
236
237 return TRUE;
238 }
239
240 /* Canonicalize the relocs. */
241
242 static long
elf64_sparc_canonicalize_reloc(bfd * abfd,sec_ptr section,arelent ** relptr,asymbol ** symbols)243 elf64_sparc_canonicalize_reloc (bfd *abfd, sec_ptr section,
244 arelent **relptr, asymbol **symbols)
245 {
246 arelent *tblptr;
247 unsigned int i;
248 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
249
250 if (! bed->s->slurp_reloc_table (abfd, section, symbols, FALSE))
251 return -1;
252
253 tblptr = section->relocation;
254 for (i = 0; i < canon_reloc_count (section); i++)
255 *relptr++ = tblptr++;
256
257 *relptr = NULL;
258
259 return canon_reloc_count (section);
260 }
261
262
263 /* Canonicalize the dynamic relocation entries. Note that we return
264 the dynamic relocations as a single block, although they are
265 actually associated with particular sections; the interface, which
266 was designed for SunOS style shared libraries, expects that there
267 is only one set of dynamic relocs. Any section that was actually
268 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses
269 the dynamic symbol table, is considered to be a dynamic reloc
270 section. */
271
272 static long
elf64_sparc_canonicalize_dynamic_reloc(bfd * abfd,arelent ** storage,asymbol ** syms)273 elf64_sparc_canonicalize_dynamic_reloc (bfd *abfd, arelent **storage,
274 asymbol **syms)
275 {
276 asection *s;
277 long ret;
278
279 if (elf_dynsymtab (abfd) == 0)
280 {
281 bfd_set_error (bfd_error_invalid_operation);
282 return -1;
283 }
284
285 ret = 0;
286 for (s = abfd->sections; s != NULL; s = s->next)
287 {
288 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
289 && (elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
290 {
291 arelent *p;
292 long count, i;
293
294 if (! elf64_sparc_slurp_reloc_table (abfd, s, syms, TRUE))
295 return -1;
296 count = canon_reloc_count (s);
297 p = s->relocation;
298 for (i = 0; i < count; i++)
299 *storage++ = p++;
300 ret += count;
301 }
302 }
303
304 *storage = NULL;
305
306 return ret;
307 }
308
309 /* Install a new set of internal relocs. */
310
311 static void
elf64_sparc_set_reloc(bfd * abfd ATTRIBUTE_UNUSED,asection * asect,arelent ** location,unsigned int count)312 elf64_sparc_set_reloc (bfd *abfd ATTRIBUTE_UNUSED,
313 asection *asect,
314 arelent **location,
315 unsigned int count)
316 {
317 asect->orelocation = location;
318 canon_reloc_count (asect) = count;
319 }
320
321 /* Write out the relocs. */
322
323 static void
elf64_sparc_write_relocs(bfd * abfd,asection * sec,void * data)324 elf64_sparc_write_relocs (bfd *abfd, asection *sec, void * data)
325 {
326 bfd_boolean *failedp = (bfd_boolean *) data;
327 Elf_Internal_Shdr *rela_hdr;
328 bfd_vma addr_offset;
329 Elf64_External_Rela *outbound_relocas, *src_rela;
330 unsigned int idx, count;
331 asymbol *last_sym = 0;
332 int last_sym_idx = 0;
333
334 /* If we have already failed, don't do anything. */
335 if (*failedp)
336 return;
337
338 if ((sec->flags & SEC_RELOC) == 0)
339 return;
340
341 /* The linker backend writes the relocs out itself, and sets the
342 reloc_count field to zero to inhibit writing them here. Also,
343 sometimes the SEC_RELOC flag gets set even when there aren't any
344 relocs. */
345 if (canon_reloc_count (sec) == 0)
346 return;
347
348 /* We can combine two relocs that refer to the same address
349 into R_SPARC_OLO10 if first one is R_SPARC_LO10 and the
350 latter is R_SPARC_13 with no associated symbol. */
351 count = 0;
352 for (idx = 0; idx < canon_reloc_count (sec); idx++)
353 {
354 bfd_vma addr;
355
356 ++count;
357
358 addr = sec->orelocation[idx]->address;
359 if (sec->orelocation[idx]->howto->type == R_SPARC_LO10
360 && idx < canon_reloc_count (sec) - 1)
361 {
362 arelent *r = sec->orelocation[idx + 1];
363
364 if (r->howto->type == R_SPARC_13
365 && r->address == addr
366 && bfd_is_abs_section ((*r->sym_ptr_ptr)->section)
367 && (*r->sym_ptr_ptr)->value == 0)
368 ++idx;
369 }
370 }
371
372 rela_hdr = elf_section_data (sec)->rela.hdr;
373
374 rela_hdr->sh_size = rela_hdr->sh_entsize * count;
375 rela_hdr->contents = bfd_alloc (abfd, rela_hdr->sh_size);
376 if (rela_hdr->contents == NULL)
377 {
378 *failedp = TRUE;
379 return;
380 }
381
382 /* Figure out whether the relocations are RELA or REL relocations. */
383 if (rela_hdr->sh_type != SHT_RELA)
384 abort ();
385
386 /* The address of an ELF reloc is section relative for an object
387 file, and absolute for an executable file or shared library.
388 The address of a BFD reloc is always section relative. */
389 addr_offset = 0;
390 if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
391 addr_offset = sec->vma;
392
393 /* orelocation has the data, reloc_count has the count... */
394 outbound_relocas = (Elf64_External_Rela *) rela_hdr->contents;
395 src_rela = outbound_relocas;
396
397 for (idx = 0; idx < canon_reloc_count (sec); idx++)
398 {
399 Elf_Internal_Rela dst_rela;
400 arelent *ptr;
401 asymbol *sym;
402 int n;
403
404 ptr = sec->orelocation[idx];
405 sym = *ptr->sym_ptr_ptr;
406 if (sym == last_sym)
407 n = last_sym_idx;
408 else if (bfd_is_abs_section (sym->section) && sym->value == 0)
409 n = STN_UNDEF;
410 else
411 {
412 last_sym = sym;
413 n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym);
414 if (n < 0)
415 {
416 *failedp = TRUE;
417 return;
418 }
419 last_sym_idx = n;
420 }
421
422 if ((*ptr->sym_ptr_ptr)->the_bfd != NULL
423 && (*ptr->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec
424 && ! _bfd_elf_validate_reloc (abfd, ptr))
425 {
426 *failedp = TRUE;
427 return;
428 }
429
430 if (ptr->howto->type == R_SPARC_LO10
431 && idx < canon_reloc_count (sec) - 1)
432 {
433 arelent *r = sec->orelocation[idx + 1];
434
435 if (r->howto->type == R_SPARC_13
436 && r->address == ptr->address
437 && bfd_is_abs_section ((*r->sym_ptr_ptr)->section)
438 && (*r->sym_ptr_ptr)->value == 0)
439 {
440 idx++;
441 dst_rela.r_info
442 = ELF64_R_INFO (n, ELF64_R_TYPE_INFO (r->addend,
443 R_SPARC_OLO10));
444 }
445 else
446 dst_rela.r_info = ELF64_R_INFO (n, R_SPARC_LO10);
447 }
448 else
449 dst_rela.r_info = ELF64_R_INFO (n, ptr->howto->type);
450
451 dst_rela.r_offset = ptr->address + addr_offset;
452 dst_rela.r_addend = ptr->addend;
453
454 bfd_elf64_swap_reloca_out (abfd, &dst_rela, (bfd_byte *) src_rela);
455 ++src_rela;
456 }
457 }
458
459 /* Hook called by the linker routine which adds symbols from an object
460 file. We use it for STT_REGISTER symbols. */
461
462 static bfd_boolean
elf64_sparc_add_symbol_hook(bfd * abfd,struct bfd_link_info * info,Elf_Internal_Sym * sym,const char ** namep,flagword * flagsp ATTRIBUTE_UNUSED,asection ** secp ATTRIBUTE_UNUSED,bfd_vma * valp ATTRIBUTE_UNUSED)463 elf64_sparc_add_symbol_hook (bfd *abfd, struct bfd_link_info *info,
464 Elf_Internal_Sym *sym, const char **namep,
465 flagword *flagsp ATTRIBUTE_UNUSED,
466 asection **secp ATTRIBUTE_UNUSED,
467 bfd_vma *valp ATTRIBUTE_UNUSED)
468 {
469 static const char *const stt_types[] = { "NOTYPE", "OBJECT", "FUNCTION" };
470
471 if (ELF_ST_TYPE (sym->st_info) == STT_REGISTER)
472 {
473 int reg;
474 struct _bfd_sparc_elf_app_reg *p;
475
476 reg = (int)sym->st_value;
477 switch (reg & ~1)
478 {
479 case 2: reg -= 2; break;
480 case 6: reg -= 4; break;
481 default:
482 _bfd_error_handler
483 (_("%pB: only registers %%g[2367] can be declared using STT_REGISTER"),
484 abfd);
485 return FALSE;
486 }
487
488 if (info->output_bfd->xvec != abfd->xvec
489 || (abfd->flags & DYNAMIC) != 0)
490 {
491 /* STT_REGISTER only works when linking an elf64_sparc object.
492 If STT_REGISTER comes from a dynamic object, don't put it into
493 the output bfd. The dynamic linker will recheck it. */
494 *namep = NULL;
495 return TRUE;
496 }
497
498 p = _bfd_sparc_elf_hash_table(info)->app_regs + reg;
499
500 if (p->name != NULL && strcmp (p->name, *namep))
501 {
502 _bfd_error_handler
503 /* xgettext:c-format */
504 (_("register %%g%d used incompatibly: %s in %pB,"
505 " previously %s in %pB"),
506 (int) sym->st_value, **namep ? *namep : "#scratch", abfd,
507 *p->name ? p->name : "#scratch", p->abfd);
508 return FALSE;
509 }
510
511 if (p->name == NULL)
512 {
513 if (**namep)
514 {
515 struct elf_link_hash_entry *h;
516
517 h = (struct elf_link_hash_entry *)
518 bfd_link_hash_lookup (info->hash, *namep, FALSE, FALSE, FALSE);
519
520 if (h != NULL)
521 {
522 unsigned char type = h->type;
523
524 if (type > STT_FUNC)
525 type = 0;
526 _bfd_error_handler
527 /* xgettext:c-format */
528 (_("symbol `%s' has differing types: REGISTER in %pB,"
529 " previously %s in %pB"),
530 *namep, abfd, stt_types[type], p->abfd);
531 return FALSE;
532 }
533
534 p->name = bfd_hash_allocate (&info->hash->table,
535 strlen (*namep) + 1);
536 if (!p->name)
537 return FALSE;
538
539 strcpy (p->name, *namep);
540 }
541 else
542 p->name = "";
543 p->bind = ELF_ST_BIND (sym->st_info);
544 p->abfd = abfd;
545 p->shndx = sym->st_shndx;
546 }
547 else
548 {
549 if (p->bind == STB_WEAK
550 && ELF_ST_BIND (sym->st_info) == STB_GLOBAL)
551 {
552 p->bind = STB_GLOBAL;
553 p->abfd = abfd;
554 }
555 }
556 *namep = NULL;
557 return TRUE;
558 }
559 else if (*namep && **namep
560 && info->output_bfd->xvec == abfd->xvec)
561 {
562 int i;
563 struct _bfd_sparc_elf_app_reg *p;
564
565 p = _bfd_sparc_elf_hash_table(info)->app_regs;
566 for (i = 0; i < 4; i++, p++)
567 if (p->name != NULL && ! strcmp (p->name, *namep))
568 {
569 unsigned char type = ELF_ST_TYPE (sym->st_info);
570
571 if (type > STT_FUNC)
572 type = 0;
573 _bfd_error_handler
574 /* xgettext:c-format */
575 (_("Symbol `%s' has differing types: %s in %pB,"
576 " previously REGISTER in %pB"),
577 *namep, stt_types[type], abfd, p->abfd);
578 return FALSE;
579 }
580 }
581 return TRUE;
582 }
583
584 /* This function takes care of emitting STT_REGISTER symbols
585 which we cannot easily keep in the symbol hash table. */
586
587 static bfd_boolean
elf64_sparc_output_arch_syms(bfd * output_bfd ATTRIBUTE_UNUSED,struct bfd_link_info * info,void * flaginfo,int (* func)(void *,const char *,Elf_Internal_Sym *,asection *,struct elf_link_hash_entry *))588 elf64_sparc_output_arch_syms (bfd *output_bfd ATTRIBUTE_UNUSED,
589 struct bfd_link_info *info,
590 void * flaginfo,
591 int (*func) (void *, const char *,
592 Elf_Internal_Sym *,
593 asection *,
594 struct elf_link_hash_entry *))
595 {
596 int reg;
597 struct _bfd_sparc_elf_app_reg *app_regs =
598 _bfd_sparc_elf_hash_table(info)->app_regs;
599 Elf_Internal_Sym sym;
600
601 for (reg = 0; reg < 4; reg++)
602 if (app_regs [reg].name != NULL)
603 {
604 if (info->strip == strip_some
605 && bfd_hash_lookup (info->keep_hash,
606 app_regs [reg].name,
607 FALSE, FALSE) == NULL)
608 continue;
609
610 sym.st_value = reg < 2 ? reg + 2 : reg + 4;
611 sym.st_size = 0;
612 sym.st_other = 0;
613 sym.st_info = ELF_ST_INFO (app_regs [reg].bind, STT_REGISTER);
614 sym.st_shndx = app_regs [reg].shndx;
615 sym.st_target_internal = 0;
616 if ((*func) (flaginfo, app_regs [reg].name, &sym,
617 sym.st_shndx == SHN_ABS
618 ? bfd_abs_section_ptr : bfd_und_section_ptr,
619 NULL) != 1)
620 return FALSE;
621 }
622
623 return TRUE;
624 }
625
626 static int
elf64_sparc_get_symbol_type(Elf_Internal_Sym * elf_sym,int type)627 elf64_sparc_get_symbol_type (Elf_Internal_Sym *elf_sym, int type)
628 {
629 if (ELF_ST_TYPE (elf_sym->st_info) == STT_REGISTER)
630 return STT_REGISTER;
631 else
632 return type;
633 }
634
635 /* A STB_GLOBAL,STT_REGISTER symbol should be BSF_GLOBAL
636 even in SHN_UNDEF section. */
637
638 static void
elf64_sparc_symbol_processing(bfd * abfd ATTRIBUTE_UNUSED,asymbol * asym)639 elf64_sparc_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED, asymbol *asym)
640 {
641 elf_symbol_type *elfsym;
642
643 elfsym = (elf_symbol_type *) asym;
644 if (elfsym->internal_elf_sym.st_info
645 == ELF_ST_INFO (STB_GLOBAL, STT_REGISTER))
646 {
647 asym->flags |= BSF_GLOBAL;
648 }
649 }
650
651
652 /* Functions for dealing with the e_flags field. */
653
654 /* Merge backend specific data from an object file to the output
655 object file when linking. */
656
657 static bfd_boolean
elf64_sparc_merge_private_bfd_data(bfd * ibfd,struct bfd_link_info * info)658 elf64_sparc_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
659 {
660 bfd *obfd = info->output_bfd;
661 bfd_boolean error;
662 flagword new_flags, old_flags;
663 int new_mm, old_mm;
664
665 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
666 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
667 return TRUE;
668
669 new_flags = elf_elfheader (ibfd)->e_flags;
670 old_flags = elf_elfheader (obfd)->e_flags;
671
672 if (!elf_flags_init (obfd)) /* First call, no flags set */
673 {
674 elf_flags_init (obfd) = TRUE;
675 elf_elfheader (obfd)->e_flags = new_flags;
676 }
677
678 else if (new_flags == old_flags) /* Compatible flags are ok */
679 ;
680
681 else /* Incompatible flags */
682 {
683 error = FALSE;
684
685 #define EF_SPARC_ISA_EXTENSIONS \
686 (EF_SPARC_SUN_US1 | EF_SPARC_SUN_US3 | EF_SPARC_HAL_R1)
687
688 if ((ibfd->flags & DYNAMIC) != 0)
689 {
690 /* We don't want dynamic objects memory ordering and
691 architecture to have any role. That's what dynamic linker
692 should do. */
693 new_flags &= ~(EF_SPARCV9_MM | EF_SPARC_ISA_EXTENSIONS);
694 new_flags |= (old_flags
695 & (EF_SPARCV9_MM | EF_SPARC_ISA_EXTENSIONS));
696 }
697 else
698 {
699 /* Choose the highest architecture requirements. */
700 old_flags |= (new_flags & EF_SPARC_ISA_EXTENSIONS);
701 new_flags |= (old_flags & EF_SPARC_ISA_EXTENSIONS);
702 if ((old_flags & (EF_SPARC_SUN_US1 | EF_SPARC_SUN_US3))
703 && (old_flags & EF_SPARC_HAL_R1))
704 {
705 error = TRUE;
706 _bfd_error_handler
707 (_("%pB: linking UltraSPARC specific with HAL specific code"),
708 ibfd);
709 }
710 /* Choose the most restrictive memory ordering. */
711 old_mm = (old_flags & EF_SPARCV9_MM);
712 new_mm = (new_flags & EF_SPARCV9_MM);
713 old_flags &= ~EF_SPARCV9_MM;
714 new_flags &= ~EF_SPARCV9_MM;
715 if (new_mm < old_mm)
716 old_mm = new_mm;
717 old_flags |= old_mm;
718 new_flags |= old_mm;
719 }
720
721 /* Warn about any other mismatches */
722 if (new_flags != old_flags)
723 {
724 error = TRUE;
725 _bfd_error_handler
726 /* xgettext:c-format */
727 (_("%pB: uses different e_flags (%#x) fields than previous modules (%#x)"),
728 ibfd, new_flags, old_flags);
729 }
730
731 elf_elfheader (obfd)->e_flags = old_flags;
732
733 if (error)
734 {
735 bfd_set_error (bfd_error_bad_value);
736 return FALSE;
737 }
738 }
739 return _bfd_sparc_elf_merge_private_bfd_data (ibfd, info);
740 }
741
742 /* MARCO: Set the correct entry size for the .stab section. */
743
744 static bfd_boolean
elf64_sparc_fake_sections(bfd * abfd ATTRIBUTE_UNUSED,Elf_Internal_Shdr * hdr ATTRIBUTE_UNUSED,asection * sec)745 elf64_sparc_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
746 Elf_Internal_Shdr *hdr ATTRIBUTE_UNUSED,
747 asection *sec)
748 {
749 const char *name;
750
751 name = bfd_section_name (sec);
752
753 if (strcmp (name, ".stab") == 0)
754 {
755 /* Even in the 64bit case the stab entries are only 12 bytes long. */
756 elf_section_data (sec)->this_hdr.sh_entsize = 12;
757 }
758
759 return TRUE;
760 }
761
762 /* Print a STT_REGISTER symbol to file FILE. */
763
764 static const char *
elf64_sparc_print_symbol_all(bfd * abfd ATTRIBUTE_UNUSED,void * filep,asymbol * symbol)765 elf64_sparc_print_symbol_all (bfd *abfd ATTRIBUTE_UNUSED, void * filep,
766 asymbol *symbol)
767 {
768 FILE *file = (FILE *) filep;
769 int reg, type;
770
771 if (ELF_ST_TYPE (((elf_symbol_type *) symbol)->internal_elf_sym.st_info)
772 != STT_REGISTER)
773 return NULL;
774
775 reg = ((elf_symbol_type *) symbol)->internal_elf_sym.st_value;
776 type = symbol->flags;
777 fprintf (file, "REG_%c%c%11s%c%c R", "GOLI" [reg / 8], '0' + (reg & 7), "",
778 ((type & BSF_LOCAL)
779 ? (type & BSF_GLOBAL) ? '!' : 'l'
780 : (type & BSF_GLOBAL) ? 'g' : ' '),
781 (type & BSF_WEAK) ? 'w' : ' ');
782 if (symbol->name == NULL || symbol->name [0] == '\0')
783 return "#scratch";
784 else
785 return symbol->name;
786 }
787
788 /* Used to decide how to sort relocs in an optimal manner for the
789 dynamic linker, before writing them out. */
790
791 static enum elf_reloc_type_class
elf64_sparc_reloc_type_class(const struct bfd_link_info * info,const asection * rel_sec ATTRIBUTE_UNUSED,const Elf_Internal_Rela * rela)792 elf64_sparc_reloc_type_class (const struct bfd_link_info *info,
793 const asection *rel_sec ATTRIBUTE_UNUSED,
794 const Elf_Internal_Rela *rela)
795 {
796 bfd *abfd = info->output_bfd;
797 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
798 struct _bfd_sparc_elf_link_hash_table *htab
799 = _bfd_sparc_elf_hash_table (info);
800 BFD_ASSERT (htab != NULL);
801
802 if (htab->elf.dynsym != NULL
803 && htab->elf.dynsym->contents != NULL)
804 {
805 /* Check relocation against STT_GNU_IFUNC symbol if there are
806 dynamic symbols. */
807 unsigned long r_symndx = htab->r_symndx (rela->r_info);
808 if (r_symndx != STN_UNDEF)
809 {
810 Elf_Internal_Sym sym;
811 if (!bed->s->swap_symbol_in (abfd,
812 (htab->elf.dynsym->contents
813 + r_symndx * bed->s->sizeof_sym),
814 0, &sym))
815 abort ();
816
817 if (ELF_ST_TYPE (sym.st_info) == STT_GNU_IFUNC)
818 return reloc_class_ifunc;
819 }
820 }
821
822 switch ((int) ELF64_R_TYPE (rela->r_info))
823 {
824 case R_SPARC_IRELATIVE:
825 return reloc_class_ifunc;
826 case R_SPARC_RELATIVE:
827 return reloc_class_relative;
828 case R_SPARC_JMP_SLOT:
829 return reloc_class_plt;
830 case R_SPARC_COPY:
831 return reloc_class_copy;
832 default:
833 return reloc_class_normal;
834 }
835 }
836
837 /* Relocations in the 64 bit SPARC ELF ABI are more complex than in
838 standard ELF, because R_SPARC_OLO10 has secondary addend in
839 ELF64_R_TYPE_DATA field. This structure is used to redirect the
840 relocation handling routines. */
841
842 const struct elf_size_info elf64_sparc_size_info =
843 {
844 sizeof (Elf64_External_Ehdr),
845 sizeof (Elf64_External_Phdr),
846 sizeof (Elf64_External_Shdr),
847 sizeof (Elf64_External_Rel),
848 sizeof (Elf64_External_Rela),
849 sizeof (Elf64_External_Sym),
850 sizeof (Elf64_External_Dyn),
851 sizeof (Elf_External_Note),
852 4, /* hash-table entry size. */
853 /* Internal relocations per external relocations.
854 For link purposes we use just 1 internal per
855 1 external, for assembly and slurp symbol table
856 we use 2. */
857 1,
858 64, /* arch_size. */
859 3, /* log_file_align. */
860 ELFCLASS64,
861 EV_CURRENT,
862 bfd_elf64_write_out_phdrs,
863 bfd_elf64_write_shdrs_and_ehdr,
864 bfd_elf64_checksum_contents,
865 elf64_sparc_write_relocs,
866 bfd_elf64_swap_symbol_in,
867 bfd_elf64_swap_symbol_out,
868 elf64_sparc_slurp_reloc_table,
869 bfd_elf64_slurp_symbol_table,
870 bfd_elf64_swap_dyn_in,
871 bfd_elf64_swap_dyn_out,
872 bfd_elf64_swap_reloc_in,
873 bfd_elf64_swap_reloc_out,
874 bfd_elf64_swap_reloca_in,
875 bfd_elf64_swap_reloca_out
876 };
877
878 #define TARGET_BIG_SYM sparc_elf64_vec
879 #define TARGET_BIG_NAME "elf64-sparc"
880 #define ELF_ARCH bfd_arch_sparc
881 #define ELF_MAXPAGESIZE 0x100000
882 #define ELF_COMMONPAGESIZE 0x2000
883
884 /* This is the official ABI value. */
885 #define ELF_MACHINE_CODE EM_SPARCV9
886
887 /* This is the value that we used before the ABI was released. */
888 #define ELF_MACHINE_ALT1 EM_OLD_SPARCV9
889
890 #define elf_backend_reloc_type_class \
891 elf64_sparc_reloc_type_class
892 #define bfd_elf64_get_reloc_upper_bound \
893 elf64_sparc_get_reloc_upper_bound
894 #define bfd_elf64_get_dynamic_reloc_upper_bound \
895 elf64_sparc_get_dynamic_reloc_upper_bound
896 #define bfd_elf64_canonicalize_reloc \
897 elf64_sparc_canonicalize_reloc
898 #define bfd_elf64_canonicalize_dynamic_reloc \
899 elf64_sparc_canonicalize_dynamic_reloc
900 #define bfd_elf64_set_reloc \
901 elf64_sparc_set_reloc
902 #define elf_backend_add_symbol_hook \
903 elf64_sparc_add_symbol_hook
904 #define elf_backend_get_symbol_type \
905 elf64_sparc_get_symbol_type
906 #define elf_backend_symbol_processing \
907 elf64_sparc_symbol_processing
908 #define elf_backend_print_symbol_all \
909 elf64_sparc_print_symbol_all
910 #define elf_backend_output_arch_syms \
911 elf64_sparc_output_arch_syms
912 #define bfd_elf64_bfd_merge_private_bfd_data \
913 elf64_sparc_merge_private_bfd_data
914 #define elf_backend_fake_sections \
915 elf64_sparc_fake_sections
916 #define elf_backend_size_info \
917 elf64_sparc_size_info
918
919 #define elf_backend_plt_sym_val \
920 _bfd_sparc_elf_plt_sym_val
921 #define bfd_elf64_bfd_link_hash_table_create \
922 _bfd_sparc_elf_link_hash_table_create
923 #define elf_info_to_howto \
924 _bfd_sparc_elf_info_to_howto
925 #define elf_backend_copy_indirect_symbol \
926 _bfd_sparc_elf_copy_indirect_symbol
927 #define bfd_elf64_bfd_reloc_type_lookup \
928 _bfd_sparc_elf_reloc_type_lookup
929 #define bfd_elf64_bfd_reloc_name_lookup \
930 _bfd_sparc_elf_reloc_name_lookup
931 #define bfd_elf64_bfd_relax_section \
932 _bfd_sparc_elf_relax_section
933 #define bfd_elf64_new_section_hook \
934 _bfd_sparc_elf_new_section_hook
935
936 #define elf_backend_create_dynamic_sections \
937 _bfd_sparc_elf_create_dynamic_sections
938 #define elf_backend_relocs_compatible \
939 _bfd_elf_relocs_compatible
940 #define elf_backend_check_relocs \
941 _bfd_sparc_elf_check_relocs
942 #define elf_backend_adjust_dynamic_symbol \
943 _bfd_sparc_elf_adjust_dynamic_symbol
944 #define elf_backend_omit_section_dynsym \
945 _bfd_sparc_elf_omit_section_dynsym
946 #define elf_backend_size_dynamic_sections \
947 _bfd_sparc_elf_size_dynamic_sections
948 #define elf_backend_relocate_section \
949 _bfd_sparc_elf_relocate_section
950 #define elf_backend_finish_dynamic_symbol \
951 _bfd_sparc_elf_finish_dynamic_symbol
952 #define elf_backend_finish_dynamic_sections \
953 _bfd_sparc_elf_finish_dynamic_sections
954 #define elf_backend_fixup_symbol \
955 _bfd_sparc_elf_fixup_symbol
956
957 #define bfd_elf64_mkobject \
958 _bfd_sparc_elf_mkobject
959 #define elf_backend_object_p \
960 _bfd_sparc_elf_object_p
961 #define elf_backend_gc_mark_hook \
962 _bfd_sparc_elf_gc_mark_hook
963 #define elf_backend_init_index_section \
964 _bfd_elf_init_1_index_section
965
966 #define elf_backend_can_gc_sections 1
967 #define elf_backend_can_refcount 1
968 #define elf_backend_want_got_plt 0
969 #define elf_backend_plt_readonly 0
970 #define elf_backend_want_plt_sym 1
971 #define elf_backend_got_header_size 8
972 #define elf_backend_want_dynrelro 1
973 #define elf_backend_rela_normal 1
974
975 /* Section 5.2.4 of the ABI specifies a 256-byte boundary for the table. */
976 #define elf_backend_plt_alignment 8
977
978 #include "elf64-target.h"
979
980 /* FreeBSD support */
981 #undef TARGET_BIG_SYM
982 #define TARGET_BIG_SYM sparc_elf64_fbsd_vec
983 #undef TARGET_BIG_NAME
984 #define TARGET_BIG_NAME "elf64-sparc-freebsd"
985 #undef ELF_OSABI
986 #define ELF_OSABI ELFOSABI_FREEBSD
987
988 #undef elf64_bed
989 #define elf64_bed elf64_sparc_fbsd_bed
990
991 #include "elf64-target.h"
992
993 /* Solaris 2. */
994
995 #undef TARGET_BIG_SYM
996 #define TARGET_BIG_SYM sparc_elf64_sol2_vec
997 #undef TARGET_BIG_NAME
998 #define TARGET_BIG_NAME "elf64-sparc-sol2"
999
1000 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
1001 objects won't be recognized. */
1002 #undef ELF_OSABI
1003
1004 #undef elf64_bed
1005 #define elf64_bed elf64_sparc_sol2_bed
1006
1007 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
1008 boundary. */
1009 #undef elf_backend_static_tls_alignment
1010 #define elf_backend_static_tls_alignment 16
1011
1012 #include "elf64-target.h"
1013