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