bfd/elf64-sparc.c

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