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