bfd/elf64-sparc.c

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