bfd/elf64-sparc.c

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