bfd/elf64-sparc.c

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