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