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