bfd/elf64-sparc.c

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