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