Don't call bfd_link_hash_table_free
[external/binutils.git] / bfd / elf64-sparc.c
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
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
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
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
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
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
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
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 \f
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
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 ((abfd->flags & DYNAMIC) == 0
428       && (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC
429           || ELF_ST_BIND (sym->st_info) == STB_GNU_UNIQUE))
430     elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
431
432   if (ELF_ST_TYPE (sym->st_info) == STT_REGISTER)
433     {
434       int reg;
435       struct _bfd_sparc_elf_app_reg *p;
436
437       reg = (int)sym->st_value;
438       switch (reg & ~1)
439         {
440         case 2: reg -= 2; break;
441         case 6: reg -= 4; break;
442         default:
443           (*_bfd_error_handler)
444             (_("%B: Only registers %%g[2367] can be declared using STT_REGISTER"),
445              abfd);
446           return FALSE;
447         }
448
449       if (info->output_bfd->xvec != abfd->xvec
450           || (abfd->flags & DYNAMIC) != 0)
451         {
452           /* STT_REGISTER only works when linking an elf64_sparc object.
453              If STT_REGISTER comes from a dynamic object, don't put it into
454              the output bfd.  The dynamic linker will recheck it.  */
455           *namep = NULL;
456           return TRUE;
457         }
458
459       p = _bfd_sparc_elf_hash_table(info)->app_regs + reg;
460
461       if (p->name != NULL && strcmp (p->name, *namep))
462         {
463           (*_bfd_error_handler)
464             (_("Register %%g%d used incompatibly: %s in %B, previously %s in %B"),
465              abfd, p->abfd, (int) sym->st_value,
466              **namep ? *namep : "#scratch",
467              *p->name ? p->name : "#scratch");
468           return FALSE;
469         }
470
471       if (p->name == NULL)
472         {
473           if (**namep)
474             {
475               struct elf_link_hash_entry *h;
476
477               h = (struct elf_link_hash_entry *)
478                 bfd_link_hash_lookup (info->hash, *namep, FALSE, FALSE, FALSE);
479
480               if (h != NULL)
481                 {
482                   unsigned char type = h->type;
483
484                   if (type > STT_FUNC)
485                     type = 0;
486                   (*_bfd_error_handler)
487                     (_("Symbol `%s' has differing types: REGISTER in %B, previously %s in %B"),
488                      abfd, p->abfd, *namep, stt_types[type]);
489                   return FALSE;
490                 }
491
492               p->name = bfd_hash_allocate (&info->hash->table,
493                                            strlen (*namep) + 1);
494               if (!p->name)
495                 return FALSE;
496
497               strcpy (p->name, *namep);
498             }
499           else
500             p->name = "";
501           p->bind = ELF_ST_BIND (sym->st_info);
502           p->abfd = abfd;
503           p->shndx = sym->st_shndx;
504         }
505       else
506         {
507           if (p->bind == STB_WEAK
508               && ELF_ST_BIND (sym->st_info) == STB_GLOBAL)
509             {
510               p->bind = STB_GLOBAL;
511               p->abfd = abfd;
512             }
513         }
514       *namep = NULL;
515       return TRUE;
516     }
517   else if (*namep && **namep
518            && info->output_bfd->xvec == abfd->xvec)
519     {
520       int i;
521       struct _bfd_sparc_elf_app_reg *p;
522
523       p = _bfd_sparc_elf_hash_table(info)->app_regs;
524       for (i = 0; i < 4; i++, p++)
525         if (p->name != NULL && ! strcmp (p->name, *namep))
526           {
527             unsigned char type = ELF_ST_TYPE (sym->st_info);
528
529             if (type > STT_FUNC)
530               type = 0;
531             (*_bfd_error_handler)
532               (_("Symbol `%s' has differing types: %s in %B, previously REGISTER in %B"),
533                abfd, p->abfd, *namep, stt_types[type]);
534             return FALSE;
535           }
536     }
537   return TRUE;
538 }
539
540 /* This function takes care of emitting STT_REGISTER symbols
541    which we cannot easily keep in the symbol hash table.  */
542
543 static bfd_boolean
544 elf64_sparc_output_arch_syms (bfd *output_bfd ATTRIBUTE_UNUSED,
545                               struct bfd_link_info *info,
546                               void * flaginfo,
547                               int (*func) (void *, const char *,
548                                            Elf_Internal_Sym *,
549                                            asection *,
550                                            struct elf_link_hash_entry *))
551 {
552   int reg;
553   struct _bfd_sparc_elf_app_reg *app_regs =
554     _bfd_sparc_elf_hash_table(info)->app_regs;
555   Elf_Internal_Sym sym;
556
557   /* We arranged in size_dynamic_sections to put the STT_REGISTER entries
558      at the end of the dynlocal list, so they came at the end of the local
559      symbols in the symtab.  Except that they aren't STB_LOCAL, so we need
560      to back up symtab->sh_info.  */
561   if (elf_hash_table (info)->dynlocal)
562     {
563       bfd * dynobj = elf_hash_table (info)->dynobj;
564       asection *dynsymsec = bfd_get_linker_section (dynobj, ".dynsym");
565       struct elf_link_local_dynamic_entry *e;
566
567       for (e = elf_hash_table (info)->dynlocal; e ; e = e->next)
568         if (e->input_indx == -1)
569           break;
570       if (e)
571         {
572           elf_section_data (dynsymsec->output_section)->this_hdr.sh_info
573             = e->dynindx;
574         }
575     }
576
577   if (info->strip == strip_all)
578     return TRUE;
579
580   for (reg = 0; reg < 4; reg++)
581     if (app_regs [reg].name != NULL)
582       {
583         if (info->strip == strip_some
584             && bfd_hash_lookup (info->keep_hash,
585                                 app_regs [reg].name,
586                                 FALSE, FALSE) == NULL)
587           continue;
588
589         sym.st_value = reg < 2 ? reg + 2 : reg + 4;
590         sym.st_size = 0;
591         sym.st_other = 0;
592         sym.st_info = ELF_ST_INFO (app_regs [reg].bind, STT_REGISTER);
593         sym.st_shndx = app_regs [reg].shndx;
594         sym.st_target_internal = 0;
595         if ((*func) (flaginfo, app_regs [reg].name, &sym,
596                      sym.st_shndx == SHN_ABS
597                      ? bfd_abs_section_ptr : bfd_und_section_ptr,
598                      NULL) != 1)
599           return FALSE;
600       }
601
602   return TRUE;
603 }
604
605 static int
606 elf64_sparc_get_symbol_type (Elf_Internal_Sym *elf_sym, int type)
607 {
608   if (ELF_ST_TYPE (elf_sym->st_info) == STT_REGISTER)
609     return STT_REGISTER;
610   else
611     return type;
612 }
613
614 /* A STB_GLOBAL,STT_REGISTER symbol should be BSF_GLOBAL
615    even in SHN_UNDEF section.  */
616
617 static void
618 elf64_sparc_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED, asymbol *asym)
619 {
620   elf_symbol_type *elfsym;
621
622   elfsym = (elf_symbol_type *) asym;
623   if (elfsym->internal_elf_sym.st_info
624       == ELF_ST_INFO (STB_GLOBAL, STT_REGISTER))
625     {
626       asym->flags |= BSF_GLOBAL;
627     }
628 }
629
630 \f
631 /* Functions for dealing with the e_flags field.  */
632
633 /* Merge backend specific data from an object file to the output
634    object file when linking.  */
635
636 static bfd_boolean
637 elf64_sparc_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
638 {
639   bfd_boolean error;
640   flagword new_flags, old_flags;
641   int new_mm, old_mm;
642
643   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
644       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
645     return TRUE;
646
647   new_flags = elf_elfheader (ibfd)->e_flags;
648   old_flags = elf_elfheader (obfd)->e_flags;
649
650   if (!elf_flags_init (obfd))   /* First call, no flags set */
651     {
652       elf_flags_init (obfd) = TRUE;
653       elf_elfheader (obfd)->e_flags = new_flags;
654     }
655
656   else if (new_flags == old_flags)      /* Compatible flags are ok */
657     ;
658
659   else                                  /* Incompatible flags */
660     {
661       error = FALSE;
662
663 #define EF_SPARC_ISA_EXTENSIONS \
664   (EF_SPARC_SUN_US1 | EF_SPARC_SUN_US3 | EF_SPARC_HAL_R1)
665
666       if ((ibfd->flags & DYNAMIC) != 0)
667         {
668           /* We don't want dynamic objects memory ordering and
669              architecture to have any role. That's what dynamic linker
670              should do.  */
671           new_flags &= ~(EF_SPARCV9_MM | EF_SPARC_ISA_EXTENSIONS);
672           new_flags |= (old_flags
673                         & (EF_SPARCV9_MM | EF_SPARC_ISA_EXTENSIONS));
674         }
675       else
676         {
677           /* Choose the highest architecture requirements.  */
678           old_flags |= (new_flags & EF_SPARC_ISA_EXTENSIONS);
679           new_flags |= (old_flags & EF_SPARC_ISA_EXTENSIONS);
680           if ((old_flags & (EF_SPARC_SUN_US1 | EF_SPARC_SUN_US3))
681               && (old_flags & EF_SPARC_HAL_R1))
682             {
683               error = TRUE;
684               (*_bfd_error_handler)
685                 (_("%B: linking UltraSPARC specific with HAL specific code"),
686                  ibfd);
687             }
688           /* Choose the most restrictive memory ordering.  */
689           old_mm = (old_flags & EF_SPARCV9_MM);
690           new_mm = (new_flags & EF_SPARCV9_MM);
691           old_flags &= ~EF_SPARCV9_MM;
692           new_flags &= ~EF_SPARCV9_MM;
693           if (new_mm < old_mm)
694             old_mm = new_mm;
695           old_flags |= old_mm;
696           new_flags |= old_mm;
697         }
698
699       /* Warn about any other mismatches */
700       if (new_flags != old_flags)
701         {
702           error = TRUE;
703           (*_bfd_error_handler)
704             (_("%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
705              ibfd, (long) new_flags, (long) old_flags);
706         }
707
708       elf_elfheader (obfd)->e_flags = old_flags;
709
710       if (error)
711         {
712           bfd_set_error (bfd_error_bad_value);
713           return FALSE;
714         }
715     }
716   return _bfd_sparc_elf_merge_private_bfd_data (ibfd, obfd);
717 }
718
719 /* MARCO: Set the correct entry size for the .stab section.  */
720
721 static bfd_boolean
722 elf64_sparc_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
723                            Elf_Internal_Shdr *hdr ATTRIBUTE_UNUSED,
724                            asection *sec)
725 {
726   const char *name;
727
728   name = bfd_get_section_name (abfd, sec);
729
730   if (strcmp (name, ".stab") == 0)
731     {
732       /* Even in the 64bit case the stab entries are only 12 bytes long.  */
733       elf_section_data (sec)->this_hdr.sh_entsize = 12;
734     }
735
736   return TRUE;
737 }
738 \f
739 /* Print a STT_REGISTER symbol to file FILE.  */
740
741 static const char *
742 elf64_sparc_print_symbol_all (bfd *abfd ATTRIBUTE_UNUSED, void * filep,
743                               asymbol *symbol)
744 {
745   FILE *file = (FILE *) filep;
746   int reg, type;
747
748   if (ELF_ST_TYPE (((elf_symbol_type *) symbol)->internal_elf_sym.st_info)
749       != STT_REGISTER)
750     return NULL;
751
752   reg = ((elf_symbol_type *) symbol)->internal_elf_sym.st_value;
753   type = symbol->flags;
754   fprintf (file, "REG_%c%c%11s%c%c    R", "GOLI" [reg / 8], '0' + (reg & 7), "",
755                  ((type & BSF_LOCAL)
756                   ? (type & BSF_GLOBAL) ? '!' : 'l'
757                   : (type & BSF_GLOBAL) ? 'g' : ' '),
758                  (type & BSF_WEAK) ? 'w' : ' ');
759   if (symbol->name == NULL || symbol->name [0] == '\0')
760     return "#scratch";
761   else
762     return symbol->name;
763 }
764 \f
765 static enum elf_reloc_type_class
766 elf64_sparc_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
767                               const asection *rel_sec ATTRIBUTE_UNUSED,
768                               const Elf_Internal_Rela *rela)
769 {
770   switch ((int) ELF64_R_TYPE (rela->r_info))
771     {
772     case R_SPARC_RELATIVE:
773       return reloc_class_relative;
774     case R_SPARC_JMP_SLOT:
775       return reloc_class_plt;
776     case R_SPARC_COPY:
777       return reloc_class_copy;
778     default:
779       return reloc_class_normal;
780     }
781 }
782
783 /* Relocations in the 64 bit SPARC ELF ABI are more complex than in
784    standard ELF, because R_SPARC_OLO10 has secondary addend in
785    ELF64_R_TYPE_DATA field.  This structure is used to redirect the
786    relocation handling routines.  */
787
788 const struct elf_size_info elf64_sparc_size_info =
789 {
790   sizeof (Elf64_External_Ehdr),
791   sizeof (Elf64_External_Phdr),
792   sizeof (Elf64_External_Shdr),
793   sizeof (Elf64_External_Rel),
794   sizeof (Elf64_External_Rela),
795   sizeof (Elf64_External_Sym),
796   sizeof (Elf64_External_Dyn),
797   sizeof (Elf_External_Note),
798   4,            /* hash-table entry size.  */
799   /* Internal relocations per external relocations.
800      For link purposes we use just 1 internal per
801      1 external, for assembly and slurp symbol table
802      we use 2.  */
803   1,
804   64,           /* arch_size.  */
805   3,            /* log_file_align.  */
806   ELFCLASS64,
807   EV_CURRENT,
808   bfd_elf64_write_out_phdrs,
809   bfd_elf64_write_shdrs_and_ehdr,
810   bfd_elf64_checksum_contents,
811   elf64_sparc_write_relocs,
812   bfd_elf64_swap_symbol_in,
813   bfd_elf64_swap_symbol_out,
814   elf64_sparc_slurp_reloc_table,
815   bfd_elf64_slurp_symbol_table,
816   bfd_elf64_swap_dyn_in,
817   bfd_elf64_swap_dyn_out,
818   bfd_elf64_swap_reloc_in,
819   bfd_elf64_swap_reloc_out,
820   bfd_elf64_swap_reloca_in,
821   bfd_elf64_swap_reloca_out
822 };
823
824 #define TARGET_BIG_SYM  sparc_elf64_vec
825 #define TARGET_BIG_NAME "elf64-sparc"
826 #define ELF_ARCH        bfd_arch_sparc
827 #define ELF_MAXPAGESIZE 0x100000
828 #define ELF_COMMONPAGESIZE 0x2000
829
830 /* This is the official ABI value.  */
831 #define ELF_MACHINE_CODE EM_SPARCV9
832
833 /* This is the value that we used before the ABI was released.  */
834 #define ELF_MACHINE_ALT1 EM_OLD_SPARCV9
835
836 #define elf_backend_reloc_type_class \
837   elf64_sparc_reloc_type_class
838 #define bfd_elf64_get_reloc_upper_bound \
839   elf64_sparc_get_reloc_upper_bound
840 #define bfd_elf64_get_dynamic_reloc_upper_bound \
841   elf64_sparc_get_dynamic_reloc_upper_bound
842 #define bfd_elf64_canonicalize_reloc \
843   elf64_sparc_canonicalize_reloc
844 #define bfd_elf64_canonicalize_dynamic_reloc \
845   elf64_sparc_canonicalize_dynamic_reloc
846 #define elf_backend_add_symbol_hook \
847   elf64_sparc_add_symbol_hook
848 #define elf_backend_get_symbol_type \
849   elf64_sparc_get_symbol_type
850 #define elf_backend_symbol_processing \
851   elf64_sparc_symbol_processing
852 #define elf_backend_print_symbol_all \
853   elf64_sparc_print_symbol_all
854 #define elf_backend_output_arch_syms \
855   elf64_sparc_output_arch_syms
856 #define bfd_elf64_bfd_merge_private_bfd_data \
857   elf64_sparc_merge_private_bfd_data
858 #define elf_backend_fake_sections \
859   elf64_sparc_fake_sections
860 #define elf_backend_size_info \
861   elf64_sparc_size_info
862
863 #define elf_backend_plt_sym_val \
864   _bfd_sparc_elf_plt_sym_val
865 #define bfd_elf64_bfd_link_hash_table_create \
866   _bfd_sparc_elf_link_hash_table_create
867 #define elf_info_to_howto \
868   _bfd_sparc_elf_info_to_howto
869 #define elf_backend_copy_indirect_symbol \
870   _bfd_sparc_elf_copy_indirect_symbol
871 #define bfd_elf64_bfd_reloc_type_lookup \
872   _bfd_sparc_elf_reloc_type_lookup
873 #define bfd_elf64_bfd_reloc_name_lookup \
874   _bfd_sparc_elf_reloc_name_lookup
875 #define bfd_elf64_bfd_relax_section \
876   _bfd_sparc_elf_relax_section
877 #define bfd_elf64_new_section_hook \
878   _bfd_sparc_elf_new_section_hook
879
880 #define elf_backend_create_dynamic_sections \
881   _bfd_sparc_elf_create_dynamic_sections
882 #define elf_backend_relocs_compatible \
883   _bfd_elf_relocs_compatible
884 #define elf_backend_check_relocs \
885   _bfd_sparc_elf_check_relocs
886 #define elf_backend_adjust_dynamic_symbol \
887   _bfd_sparc_elf_adjust_dynamic_symbol
888 #define elf_backend_omit_section_dynsym \
889   _bfd_sparc_elf_omit_section_dynsym
890 #define elf_backend_size_dynamic_sections \
891   _bfd_sparc_elf_size_dynamic_sections
892 #define elf_backend_relocate_section \
893   _bfd_sparc_elf_relocate_section
894 #define elf_backend_finish_dynamic_symbol \
895   _bfd_sparc_elf_finish_dynamic_symbol
896 #define elf_backend_finish_dynamic_sections \
897   _bfd_sparc_elf_finish_dynamic_sections
898
899 #define bfd_elf64_mkobject \
900   _bfd_sparc_elf_mkobject
901 #define elf_backend_object_p \
902   _bfd_sparc_elf_object_p
903 #define elf_backend_gc_mark_hook \
904   _bfd_sparc_elf_gc_mark_hook
905 #define elf_backend_gc_sweep_hook \
906   _bfd_sparc_elf_gc_sweep_hook
907 #define elf_backend_init_index_section \
908   _bfd_elf_init_1_index_section
909
910 #define elf_backend_can_gc_sections 1
911 #define elf_backend_can_refcount 1
912 #define elf_backend_want_got_plt 0
913 #define elf_backend_plt_readonly 0
914 #define elf_backend_want_plt_sym 1
915 #define elf_backend_got_header_size 8
916 #define elf_backend_rela_normal 1
917
918 /* Section 5.2.4 of the ABI specifies a 256-byte boundary for the table.  */
919 #define elf_backend_plt_alignment 8
920
921 #include "elf64-target.h"
922
923 /* FreeBSD support */
924 #undef  TARGET_BIG_SYM
925 #define TARGET_BIG_SYM sparc_elf64_fbsd_vec
926 #undef  TARGET_BIG_NAME
927 #define TARGET_BIG_NAME "elf64-sparc-freebsd"
928 #undef  ELF_OSABI
929 #define ELF_OSABI ELFOSABI_FREEBSD
930
931 #undef  elf64_bed
932 #define elf64_bed                               elf64_sparc_fbsd_bed
933
934 #include "elf64-target.h"
935
936 /* Solaris 2.  */
937
938 #undef  TARGET_BIG_SYM
939 #define TARGET_BIG_SYM                          sparc_elf64_sol2_vec
940 #undef  TARGET_BIG_NAME
941 #define TARGET_BIG_NAME                         "elf64-sparc-sol2"
942
943 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
944    objects won't be recognized.  */
945 #undef  ELF_OSABI
946
947 #undef elf64_bed
948 #define elf64_bed                               elf64_sparc_sol2_bed
949
950 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
951    boundary.  */
952 #undef elf_backend_static_tls_alignment
953 #define elf_backend_static_tls_alignment        16
954
955 #include "elf64-target.h"