bfd/elf64-sparc.c

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