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