bfd/elf64-sparc.c

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