bfd/elf32-spu.c

   1 /* SPU specific support for 32-bit ELF
   2
   3    Copyright 2006, 2007 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 along
  18    with this program; if not, write to the Free Software Foundation, Inc.,
  19    51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  20
  21 #include "sysdep.h"
  22 #include "bfd.h"
  23 #include "bfdlink.h"
  24 #include "libbfd.h"
  25 #include "elf-bfd.h"
  26 #include "elf/spu.h"
  27 #include "elf32-spu.h"
  28
  29 /* We use RELA style relocs.  Don't define USE_REL.  */
  30
  31 static bfd_reloc_status_type spu_elf_rel9 (bfd *, arelent *, asymbol *,
  32                                            void *, asection *,
  33                                            bfd *, char **);
  34
  35 /* Values of type 'enum elf_spu_reloc_type' are used to index this
  36    array, so it must be declared in the order of that type.  */
  37
  38 static reloc_howto_type elf_howto_table[] = {
  39   HOWTO (R_SPU_NONE,       0, 0,  0, FALSE,  0, complain_overflow_dont,
  40          bfd_elf_generic_reloc, "SPU_NONE",
  41          FALSE, 0, 0x00000000, FALSE),
  42   HOWTO (R_SPU_ADDR10,     4, 2, 10, FALSE, 14, complain_overflow_bitfield,
  43          bfd_elf_generic_reloc, "SPU_ADDR10",
  44          FALSE, 0, 0x00ffc000, FALSE),
  45   HOWTO (R_SPU_ADDR16,     2, 2, 16, FALSE,  7, complain_overflow_bitfield,
  46          bfd_elf_generic_reloc, "SPU_ADDR16",
  47          FALSE, 0, 0x007fff80, FALSE),
  48   HOWTO (R_SPU_ADDR16_HI, 16, 2, 16, FALSE,  7, complain_overflow_bitfield,
  49          bfd_elf_generic_reloc, "SPU_ADDR16_HI",
  50          FALSE, 0, 0x007fff80, FALSE),
  51   HOWTO (R_SPU_ADDR16_LO,  0, 2, 16, FALSE,  7, complain_overflow_dont,
  52          bfd_elf_generic_reloc, "SPU_ADDR16_LO",
  53          FALSE, 0, 0x007fff80, FALSE),
  54   HOWTO (R_SPU_ADDR18,     0, 2, 18, FALSE,  7, complain_overflow_bitfield,
  55          bfd_elf_generic_reloc, "SPU_ADDR18",
  56          FALSE, 0, 0x01ffff80, FALSE),
  57   HOWTO (R_SPU_ADDR32,   0, 2, 32, FALSE,  0, complain_overflow_dont,
  58          bfd_elf_generic_reloc, "SPU_ADDR32",
  59          FALSE, 0, 0xffffffff, FALSE),
  60   HOWTO (R_SPU_REL16,      2, 2, 16,  TRUE,  7, complain_overflow_bitfield,
  61          bfd_elf_generic_reloc, "SPU_REL16",
  62          FALSE, 0, 0x007fff80, TRUE),
  63   HOWTO (R_SPU_ADDR7,      0, 2,  7, FALSE, 14, complain_overflow_dont,
  64          bfd_elf_generic_reloc, "SPU_ADDR7",
  65          FALSE, 0, 0x001fc000, FALSE),
  66   HOWTO (R_SPU_REL9,       2, 2,  9,  TRUE,  0, complain_overflow_signed,
  67          spu_elf_rel9,          "SPU_REL9",
  68          FALSE, 0, 0x0180007f, TRUE),
  69   HOWTO (R_SPU_REL9I,      2, 2,  9,  TRUE,  0, complain_overflow_signed,
  70          spu_elf_rel9,          "SPU_REL9I",
  71          FALSE, 0, 0x0000c07f, TRUE),
  72   HOWTO (R_SPU_ADDR10I,    0, 2, 10, FALSE, 14, complain_overflow_signed,
  73          bfd_elf_generic_reloc, "SPU_ADDR10I",
  74          FALSE, 0, 0x00ffc000, FALSE),
  75   HOWTO (R_SPU_ADDR16I,    0, 2, 16, FALSE,  7, complain_overflow_signed,
  76          bfd_elf_generic_reloc, "SPU_ADDR16I",
  77          FALSE, 0, 0x007fff80, FALSE),
  78   HOWTO (R_SPU_REL32,   0, 2, 32, TRUE,  0, complain_overflow_dont,
  79          bfd_elf_generic_reloc, "SPU_REL32",
  80          FALSE, 0, 0xffffffff, TRUE),
  81   HOWTO (R_SPU_PPU32,   0, 2, 32, FALSE,  0, complain_overflow_dont,
  82          bfd_elf_generic_reloc, "SPU_PPU32",
  83          FALSE, 0, 0xffffffff, FALSE),
  84   HOWTO (R_SPU_PPU64,   0, 4, 64, FALSE,  0, complain_overflow_dont,
  85          bfd_elf_generic_reloc, "SPU_PPU64",
  86          FALSE, 0, -1, FALSE),
  87 };
  88
  89 static struct bfd_elf_special_section const spu_elf_special_sections[] = {
  90   { ".toe", 4, 0, SHT_NOBITS, SHF_ALLOC },
  91   { NULL, 0, 0, 0, 0 }
  92 };
  93
  94 static enum elf_spu_reloc_type
  95 spu_elf_bfd_to_reloc_type (bfd_reloc_code_real_type code)
  96 {
  97   switch (code)
  98     {
  99     default:
 100       return R_SPU_NONE;
 101     case BFD_RELOC_SPU_IMM10W:
 102       return R_SPU_ADDR10;
 103     case BFD_RELOC_SPU_IMM16W:
 104       return R_SPU_ADDR16;
 105     case BFD_RELOC_SPU_LO16:
 106       return R_SPU_ADDR16_LO;
 107     case BFD_RELOC_SPU_HI16:
 108       return R_SPU_ADDR16_HI;
 109     case BFD_RELOC_SPU_IMM18:
 110       return R_SPU_ADDR18;
 111     case BFD_RELOC_SPU_PCREL16:
 112       return R_SPU_REL16;
 113     case BFD_RELOC_SPU_IMM7:
 114       return R_SPU_ADDR7;
 115     case BFD_RELOC_SPU_IMM8:
 116       return R_SPU_NONE;
 117     case BFD_RELOC_SPU_PCREL9a:
 118       return R_SPU_REL9;
 119     case BFD_RELOC_SPU_PCREL9b:
 120       return R_SPU_REL9I;
 121     case BFD_RELOC_SPU_IMM10:
 122       return R_SPU_ADDR10I;
 123     case BFD_RELOC_SPU_IMM16:
 124       return R_SPU_ADDR16I;
 125     case BFD_RELOC_32:
 126       return R_SPU_ADDR32;
 127     case BFD_RELOC_32_PCREL:
 128       return R_SPU_REL32;
 129     case BFD_RELOC_SPU_PPU32:
 130       return R_SPU_PPU32;
 131     case BFD_RELOC_SPU_PPU64:
 132       return R_SPU_PPU64;
 133     }
 134 }
 135
 136 static void
 137 spu_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
 138                        arelent *cache_ptr,
 139                        Elf_Internal_Rela *dst)
 140 {
 141   enum elf_spu_reloc_type r_type;
 142
 143   r_type = (enum elf_spu_reloc_type) ELF32_R_TYPE (dst->r_info);
 144   BFD_ASSERT (r_type < R_SPU_max);
 145   cache_ptr->howto = &elf_howto_table[(int) r_type];
 146 }
 147
 148 static reloc_howto_type *
 149 spu_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 150                            bfd_reloc_code_real_type code)
 151 {
 152   enum elf_spu_reloc_type r_type = spu_elf_bfd_to_reloc_type (code);
 153
 154   if (r_type == R_SPU_NONE)
 155     return NULL;
 156
 157   return elf_howto_table + r_type;
 158 }
 159
 160 static reloc_howto_type *
 161 spu_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 162                            const char *r_name)
 163 {
 164   unsigned int i;
 165
 166   for (i = 0; i < sizeof (elf_howto_table) / sizeof (elf_howto_table[0]); i++)
 167     if (elf_howto_table[i].name != NULL
 168         && strcasecmp (elf_howto_table[i].name, r_name) == 0)
 169       return &elf_howto_table[i];
 170
 171   return NULL;
 172 }
 173
 174 /* Apply R_SPU_REL9 and R_SPU_REL9I relocs.  */
 175
 176 static bfd_reloc_status_type
 177 spu_elf_rel9 (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
 178               void *data, asection *input_section,
 179               bfd *output_bfd, char **error_message)
 180 {
 181   bfd_size_type octets;
 182   bfd_vma val;
 183   long insn;
 184
 185   /* If this is a relocatable link (output_bfd test tells us), just
 186      call the generic function.  Any adjustment will be done at final
 187      link time.  */
 188   if (output_bfd != NULL)
 189     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
 190                                   input_section, output_bfd, error_message);
 191
 192   if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
 193     return bfd_reloc_outofrange;
 194   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
 195
 196   /* Get symbol value.  */
 197   val = 0;
 198   if (!bfd_is_com_section (symbol->section))
 199     val = symbol->value;
 200   if (symbol->section->output_section)
 201     val += symbol->section->output_section->vma;
 202
 203   val += reloc_entry->addend;
 204
 205   /* Make it pc-relative.  */
 206   val -= input_section->output_section->vma + input_section->output_offset;
 207
 208   val >>= 2;
 209   if (val + 256 >= 512)
 210     return bfd_reloc_overflow;
 211
 212   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
 213
 214   /* Move two high bits of value to REL9I and REL9 position.
 215      The mask will take care of selecting the right field.  */
 216   val = (val & 0x7f) | ((val & 0x180) << 7) | ((val & 0x180) << 16);
 217   insn &= ~reloc_entry->howto->dst_mask;
 218   insn |= val & reloc_entry->howto->dst_mask;
 219   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
 220   return bfd_reloc_ok;
 221 }
 222
 223 static bfd_boolean
 224 spu_elf_new_section_hook (bfd *abfd, asection *sec)
 225 {
 226   if (!sec->used_by_bfd)
 227     {
 228       struct _spu_elf_section_data *sdata;
 229
 230       sdata = bfd_zalloc (abfd, sizeof (*sdata));
 231       if (sdata == NULL)
 232         return FALSE;
 233       sec->used_by_bfd = sdata;
 234     }
 235
 236   return _bfd_elf_new_section_hook (abfd, sec);
 237 }
 238
 239 /* Specially mark defined symbols named _EAR_* with BSF_KEEP so that
 240    strip --strip-unneeded will not remove them.  */
 241
 242 static void
 243 spu_elf_backend_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED, asymbol *sym)
 244 {
 245   if (sym->name != NULL
 246       && sym->section != bfd_abs_section_ptr
 247       && strncmp (sym->name, "_EAR_", 5) == 0)
 248     sym->flags |= BSF_KEEP;
 249 }
 250
 251 /* SPU ELF linker hash table.  */
 252
 253 struct spu_link_hash_table
 254 {
 255   struct elf_link_hash_table elf;
 256
 257   /* The stub hash table.  */
 258   struct bfd_hash_table stub_hash_table;
 259
 260   /* Shortcuts to overlay sections.  */
 261   asection *stub;
 262   asection *ovtab;
 263
 264   struct elf_link_hash_entry *ovly_load;
 265
 266   /* An array of two output sections per overlay region, chosen such that
 267      the first section vma is the overlay buffer vma (ie. the section has
 268      the lowest vma in the group that occupy the region), and the second
 269      section vma+size specifies the end of the region.  We keep pointers
 270      to sections like this because section vmas may change when laying
 271      them out.  */
 272   asection **ovl_region;
 273
 274   /* Number of overlay buffers.  */
 275   unsigned int num_buf;
 276
 277   /* Total number of overlays.  */
 278   unsigned int num_overlays;
 279
 280   /* Set if we should emit symbols for stubs.  */
 281   unsigned int emit_stub_syms:1;
 282
 283   /* Set if we want stubs on calls out of overlay regions to
 284      non-overlay regions.  */
 285   unsigned int non_overlay_stubs : 1;
 286
 287   /* Set on error.  */
 288   unsigned int stub_overflow : 1;
 289
 290   /* Set if stack size analysis should be done.  */
 291   unsigned int stack_analysis : 1;
 292
 293   /* Set if __stack_* syms will be emitted.  */
 294   unsigned int emit_stack_syms : 1;
 295 };
 296
 297 #define spu_hash_table(p) \
 298   ((struct spu_link_hash_table *) ((p)->hash))
 299
 300 struct spu_stub_hash_entry
 301 {
 302   struct bfd_hash_entry root;
 303
 304   /* Destination of this stub.  */
 305   asection *target_section;
 306   bfd_vma target_off;
 307
 308   /* Offset of entry in stub section.  */
 309   bfd_vma off;
 310
 311   /* Offset from this stub to stub that loads the overlay index.  */
 312   bfd_vma delta;
 313 };
 314
 315 /* Create an entry in a spu stub hash table.  */
 316
 317 static struct bfd_hash_entry *
 318 stub_hash_newfunc (struct bfd_hash_entry *entry,
 319                    struct bfd_hash_table *table,
 320                    const char *string)
 321 {
 322   /* Allocate the structure if it has not already been allocated by a
 323      subclass.  */
 324   if (entry == NULL)
 325     {
 326       entry = bfd_hash_allocate (table, sizeof (struct spu_stub_hash_entry));
 327       if (entry == NULL)
 328         return entry;
 329     }
 330
 331   /* Call the allocation method of the superclass.  */
 332   entry = bfd_hash_newfunc (entry, table, string);
 333   if (entry != NULL)
 334     {
 335       struct spu_stub_hash_entry *sh = (struct spu_stub_hash_entry *) entry;
 336
 337       sh->target_section = NULL;
 338       sh->target_off = 0;
 339       sh->off = 0;
 340       sh->delta = 0;
 341     }
 342
 343   return entry;
 344 }
 345
 346 /* Create a spu ELF linker hash table.  */
 347
 348 static struct bfd_link_hash_table *
 349 spu_elf_link_hash_table_create (bfd *abfd)
 350 {
 351   struct spu_link_hash_table *htab;
 352
 353   htab = bfd_malloc (sizeof (*htab));
 354   if (htab == NULL)
 355     return NULL;
 356
 357   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd,
 358                                       _bfd_elf_link_hash_newfunc,
 359                                       sizeof (struct elf_link_hash_entry)))
 360     {
 361       free (htab);
 362       return NULL;
 363     }
 364
 365   /* Init the stub hash table too.  */
 366   if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
 367                             sizeof (struct spu_stub_hash_entry)))
 368     return NULL;
 369
 370   memset (&htab->stub, 0,
 371           sizeof (*htab) - offsetof (struct spu_link_hash_table, stub));
 372
 373   return &htab->elf.root;
 374 }
 375
 376 /* Free the derived linker hash table.  */
 377
 378 static void
 379 spu_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
 380 {
 381   struct spu_link_hash_table *ret = (struct spu_link_hash_table *) hash;
 382
 383   bfd_hash_table_free (&ret->stub_hash_table);
 384   _bfd_generic_link_hash_table_free (hash);
 385 }
 386
 387 /* Find the symbol for the given R_SYMNDX in IBFD and set *HP and *SYMP
 388    to (hash, NULL) for global symbols, and (NULL, sym) for locals.  Set
 389    *SYMSECP to the symbol's section.  *LOCSYMSP caches local syms.  */
 390
 391 static bfd_boolean
 392 get_sym_h (struct elf_link_hash_entry **hp,
 393            Elf_Internal_Sym **symp,
 394            asection **symsecp,
 395            Elf_Internal_Sym **locsymsp,
 396            unsigned long r_symndx,
 397            bfd *ibfd)
 398 {
 399   Elf_Internal_Shdr *symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
 400
 401   if (r_symndx >= symtab_hdr->sh_info)
 402     {
 403       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
 404       struct elf_link_hash_entry *h;
 405
 406       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 407       while (h->root.type == bfd_link_hash_indirect
 408              || h->root.type == bfd_link_hash_warning)
 409         h = (struct elf_link_hash_entry *) h->root.u.i.link;
 410
 411       if (hp != NULL)
 412         *hp = h;
 413
 414       if (symp != NULL)
 415         *symp = NULL;
 416
 417       if (symsecp != NULL)
 418         {
 419           asection *symsec = NULL;
 420           if (h->root.type == bfd_link_hash_defined
 421               || h->root.type == bfd_link_hash_defweak)
 422             symsec = h->root.u.def.section;
 423           *symsecp = symsec;
 424         }
 425     }
 426   else
 427     {
 428       Elf_Internal_Sym *sym;
 429       Elf_Internal_Sym *locsyms = *locsymsp;
 430
 431       if (locsyms == NULL)
 432         {
 433           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
 434           if (locsyms == NULL)
 435             {
 436               size_t symcount = symtab_hdr->sh_info;
 437
 438               /* If we are reading symbols into the contents, then
 439                  read the global syms too.  This is done to cache
 440                  syms for later stack analysis.  */
 441               if ((unsigned char **) locsymsp == &symtab_hdr->contents)
 442                 symcount = symtab_hdr->sh_size / symtab_hdr->sh_entsize;
 443               locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr, symcount, 0,
 444                                               NULL, NULL, NULL);
 445             }
 446           if (locsyms == NULL)
 447             return FALSE;
 448           *locsymsp = locsyms;
 449         }
 450       sym = locsyms + r_symndx;
 451
 452       if (hp != NULL)
 453         *hp = NULL;
 454
 455       if (symp != NULL)
 456         *symp = sym;
 457
 458       if (symsecp != NULL)
 459         {
 460           asection *symsec = NULL;
 461           if ((sym->st_shndx != SHN_UNDEF
 462                && sym->st_shndx < SHN_LORESERVE)
 463               || sym->st_shndx > SHN_HIRESERVE)
 464             symsec = bfd_section_from_elf_index (ibfd, sym->st_shndx);
 465           *symsecp = symsec;
 466         }
 467     }
 468
 469   return TRUE;
 470 }
 471
 472 /* Build a name for an entry in the stub hash table.  We can't use a
 473    local symbol name because ld -r might generate duplicate local symbols.  */
 474
 475 static char *
 476 spu_stub_name (const asection *sym_sec,
 477                const struct elf_link_hash_entry *h,
 478                const Elf_Internal_Rela *rel)
 479 {
 480   char *stub_name;
 481   bfd_size_type len;
 482
 483   if (h)
 484     {
 485       len = strlen (h->root.root.string) + 1 + 8 + 1;
 486       stub_name = bfd_malloc (len);
 487       if (stub_name == NULL)
 488         return stub_name;
 489
 490       sprintf (stub_name, "%s+%x",
 491                h->root.root.string,
 492                (int) rel->r_addend & 0xffffffff);
 493       len -= 8;
 494     }
 495   else
 496     {
 497       len = 8 + 1 + 8 + 1 + 8 + 1;
 498       stub_name = bfd_malloc (len);
 499       if (stub_name == NULL)
 500         return stub_name;
 501
 502       sprintf (stub_name, "%x:%x+%x",
 503                sym_sec->id & 0xffffffff,
 504                (int) ELF32_R_SYM (rel->r_info) & 0xffffffff,
 505                (int) rel->r_addend & 0xffffffff);
 506       len = strlen (stub_name);
 507     }
 508
 509   if (stub_name[len - 2] == '+'
 510       && stub_name[len - 1] == '0'
 511       && stub_name[len] == 0)
 512     stub_name[len - 2] = 0;
 513
 514   return stub_name;
 515 }
 516
 517 /* Create the note section if not already present.  This is done early so
 518    that the linker maps the sections to the right place in the output.  */
 519
 520 bfd_boolean
 521 spu_elf_create_sections (bfd *output_bfd,
 522                          struct bfd_link_info *info,
 523                          int stack_analysis,
 524                          int emit_stack_syms)
 525 {
 526   bfd *ibfd;
 527   struct spu_link_hash_table *htab = spu_hash_table (info);
 528
 529   /* Stash some options away where we can get at them later.  */
 530   htab->stack_analysis = stack_analysis;
 531   htab->emit_stack_syms = emit_stack_syms;
 532
 533   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->next)
 534     if (bfd_get_section_by_name (ibfd, SPU_PTNOTE_SPUNAME) != NULL)
 535       break;
 536
 537   if (ibfd == NULL)
 538     {
 539       /* Make SPU_PTNOTE_SPUNAME section.  */
 540       asection *s;
 541       size_t name_len;
 542       size_t size;
 543       bfd_byte *data;
 544       flagword flags;
 545
 546       ibfd = info->input_bfds;
 547       flags = SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
 548       s = bfd_make_section_anyway_with_flags (ibfd, SPU_PTNOTE_SPUNAME, flags);
 549       if (s == NULL
 550           || !bfd_set_section_alignment (ibfd, s, 4))
 551         return FALSE;
 552
 553       name_len = strlen (bfd_get_filename (output_bfd)) + 1;
 554       size = 12 + ((sizeof (SPU_PLUGIN_NAME) + 3) & -4);
 555       size += (name_len + 3) & -4;
 556
 557       if (!bfd_set_section_size (ibfd, s, size))
 558         return FALSE;
 559
 560       data = bfd_zalloc (ibfd, size);
 561       if (data == NULL)
 562         return FALSE;
 563
 564       bfd_put_32 (ibfd, sizeof (SPU_PLUGIN_NAME), data + 0);
 565       bfd_put_32 (ibfd, name_len, data + 4);
 566       bfd_put_32 (ibfd, 1, data + 8);
 567       memcpy (data + 12, SPU_PLUGIN_NAME, sizeof (SPU_PLUGIN_NAME));
 568       memcpy (data + 12 + ((sizeof (SPU_PLUGIN_NAME) + 3) & -4),
 569               bfd_get_filename (output_bfd), name_len);
 570       s->contents = data;
 571     }
 572
 573   return TRUE;
 574 }
 575
 576 /* qsort predicate to sort sections by vma.  */
 577
 578 static int
 579 sort_sections (const void *a, const void *b)
 580 {
 581   const asection *const *s1 = a;
 582   const asection *const *s2 = b;
 583   bfd_signed_vma delta = (*s1)->vma - (*s2)->vma;
 584
 585   if (delta != 0)
 586     return delta < 0 ? -1 : 1;
 587
 588   return (*s1)->index - (*s2)->index;
 589 }
 590
 591 /* Identify overlays in the output bfd, and number them.  */
 592
 593 bfd_boolean
 594 spu_elf_find_overlays (bfd *output_bfd, struct bfd_link_info *info)
 595 {
 596   struct spu_link_hash_table *htab = spu_hash_table (info);
 597   asection **alloc_sec;
 598   unsigned int i, n, ovl_index, num_buf;
 599   asection *s;
 600   bfd_vma ovl_end;
 601
 602   if (output_bfd->section_count < 2)
 603     return FALSE;
 604
 605   alloc_sec = bfd_malloc (output_bfd->section_count * sizeof (*alloc_sec));
 606   if (alloc_sec == NULL)
 607     return FALSE;
 608
 609   /* Pick out all the alloced sections.  */
 610   for (n = 0, s = output_bfd->sections; s != NULL; s = s->next)
 611     if ((s->flags & SEC_ALLOC) != 0
 612         && (s->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) != SEC_THREAD_LOCAL
 613         && s->size != 0)
 614       alloc_sec[n++] = s;
 615
 616   if (n == 0)
 617     {
 618       free (alloc_sec);
 619       return FALSE;
 620     }
 621
 622   /* Sort them by vma.  */
 623   qsort (alloc_sec, n, sizeof (*alloc_sec), sort_sections);
 624
 625   /* Look for overlapping vmas.  Any with overlap must be overlays.
 626      Count them.  Also count the number of overlay regions and for
 627      each region save a section from that region with the lowest vma
 628      and another section with the highest end vma.  */
 629   ovl_end = alloc_sec[0]->vma + alloc_sec[0]->size;
 630   for (ovl_index = 0, num_buf = 0, i = 1; i < n; i++)
 631     {
 632       s = alloc_sec[i];
 633       if (s->vma < ovl_end)
 634         {
 635           asection *s0 = alloc_sec[i - 1];
 636
 637           if (spu_elf_section_data (s0)->ovl_index == 0)
 638             {
 639               spu_elf_section_data (s0)->ovl_index = ++ovl_index;
 640               alloc_sec[num_buf * 2] = s0;
 641               alloc_sec[num_buf * 2 + 1] = s0;
 642               num_buf++;
 643             }
 644           spu_elf_section_data (s)->ovl_index = ++ovl_index;
 645           if (ovl_end < s->vma + s->size)
 646             {
 647               ovl_end = s->vma + s->size;
 648               alloc_sec[num_buf * 2 - 1] = s;
 649             }
 650         }
 651       else
 652         ovl_end = s->vma + s->size;
 653     }
 654
 655   htab->num_overlays = ovl_index;
 656   htab->num_buf = num_buf;
 657   if (ovl_index == 0)
 658     {
 659       free (alloc_sec);
 660       return FALSE;
 661     }
 662
 663   alloc_sec = bfd_realloc (alloc_sec, num_buf * 2 * sizeof (*alloc_sec));
 664   if (alloc_sec == NULL)
 665     return FALSE;
 666
 667   htab->ovl_region = alloc_sec;
 668   return TRUE;
 669 }
 670
 671 /* One of these per stub.  */
 672 #define SIZEOF_STUB1 8
 673 #define ILA_79  0x4200004f              /* ila $79,function_address */
 674 #define BR      0x32000000              /* br stub2 */
 675
 676 /* One of these per overlay.  */
 677 #define SIZEOF_STUB2 8
 678 #define ILA_78  0x4200004e              /* ila $78,overlay_number */
 679                                         /* br __ovly_load */
 680 #define NOP     0x40200000
 681
 682 /* Return true for all relative and absolute branch instructions.
 683    bra   00110000 0..
 684    brasl 00110001 0..
 685    br    00110010 0..
 686    brsl  00110011 0..
 687    brz   00100000 0..
 688    brnz  00100001 0..
 689    brhz  00100010 0..
 690    brhnz 00100011 0..  */
 691
 692 static bfd_boolean
 693 is_branch (const unsigned char *insn)
 694 {
 695   return (insn[0] & 0xec) == 0x20 && (insn[1] & 0x80) == 0;
 696 }
 697
 698 /* Return true for branch hint instructions.
 699    hbra  0001000..
 700    hbrr  0001001..  */
 701
 702 static bfd_boolean
 703 is_hint (const unsigned char *insn)
 704 {
 705   return (insn[0] & 0xfc) == 0x10;
 706 }
 707
 708 /* Return TRUE if this reloc symbol should possibly go via an overlay stub.  */
 709
 710 static bfd_boolean
 711 needs_ovl_stub (const char *sym_name,
 712                 asection *sym_sec,
 713                 asection *input_section,
 714                 struct spu_link_hash_table *htab,
 715                 bfd_boolean is_branch)
 716 {
 717   if (htab->num_overlays == 0)
 718     return FALSE;
 719
 720   if (sym_sec == NULL
 721       || sym_sec->output_section == NULL
 722       || spu_elf_section_data (sym_sec->output_section) == NULL)
 723     return FALSE;
 724
 725   /* setjmp always goes via an overlay stub, because then the return
 726      and hence the longjmp goes via __ovly_return.  That magically
 727      makes setjmp/longjmp between overlays work.  */
 728   if (strncmp (sym_name, "setjmp", 6) == 0
 729       && (sym_name[6] == '\0' || sym_name[6] == '@'))
 730     return TRUE;
 731
 732   /* Usually, symbols in non-overlay sections don't need stubs.  */
 733   if (spu_elf_section_data (sym_sec->output_section)->ovl_index == 0
 734       && !htab->non_overlay_stubs)
 735     return FALSE;
 736
 737   /* A reference from some other section to a symbol in an overlay
 738      section needs a stub.  */
 739   if (spu_elf_section_data (sym_sec->output_section)->ovl_index
 740        != spu_elf_section_data (input_section->output_section)->ovl_index)
 741     return TRUE;
 742
 743   /* If this insn isn't a branch then we are possibly taking the
 744      address of a function and passing it out somehow.  */
 745   return !is_branch;
 746 }
 747
 748 struct stubarr {
 749   struct bfd_hash_table *stub_hash_table;
 750   struct spu_stub_hash_entry **sh;
 751   unsigned int count;
 752   int err;
 753 };
 754
 755 /* Called via elf_link_hash_traverse to allocate stubs for any _SPUEAR_
 756    symbols.  */
 757
 758 static bfd_boolean
 759 allocate_spuear_stubs (struct elf_link_hash_entry *h, void *inf)
 760 {
 761   /* Symbols starting with _SPUEAR_ need a stub because they may be
 762      invoked by the PPU.  */
 763   if ((h->root.type == bfd_link_hash_defined
 764        || h->root.type == bfd_link_hash_defweak)
 765       && h->def_regular
 766       && strncmp (h->root.root.string, "_SPUEAR_", 8) == 0)
 767     {
 768       struct stubarr *stubs = inf;
 769       static Elf_Internal_Rela zero_rel;
 770       char *stub_name = spu_stub_name (h->root.u.def.section, h, &zero_rel);
 771       struct spu_stub_hash_entry *sh;
 772
 773       if (stub_name == NULL)
 774         {
 775           stubs->err = 1;
 776           return FALSE;
 777         }
 778
 779       sh = (struct spu_stub_hash_entry *)
 780         bfd_hash_lookup (stubs->stub_hash_table, stub_name, TRUE, FALSE);
 781       if (sh == NULL)
 782         {
 783           free (stub_name);
 784           return FALSE;
 785         }
 786
 787       /* If this entry isn't new, we already have a stub.  */
 788       if (sh->target_section != NULL)
 789         {
 790           free (stub_name);
 791           return TRUE;
 792         }
 793
 794       sh->target_section = h->root.u.def.section;
 795       sh->target_off = h->root.u.def.value;
 796       stubs->count += 1;
 797     }
 798
 799   return TRUE;
 800 }
 801
 802 /* Called via bfd_hash_traverse to set up pointers to all symbols
 803    in the stub hash table.  */
 804
 805 static bfd_boolean
 806 populate_stubs (struct bfd_hash_entry *bh, void *inf)
 807 {
 808   struct stubarr *stubs = inf;
 809
 810   stubs->sh[--stubs->count] = (struct spu_stub_hash_entry *) bh;
 811   return TRUE;
 812 }
 813
 814 /* qsort predicate to sort stubs by overlay number.  */
 815
 816 static int
 817 sort_stubs (const void *a, const void *b)
 818 {
 819   const struct spu_stub_hash_entry *const *sa = a;
 820   const struct spu_stub_hash_entry *const *sb = b;
 821   int i;
 822   bfd_signed_vma d;
 823
 824   i = spu_elf_section_data ((*sa)->target_section->output_section)->ovl_index;
 825   i -= spu_elf_section_data ((*sb)->target_section->output_section)->ovl_index;
 826   if (i != 0)
 827     return i;
 828
 829   d = ((*sa)->target_section->output_section->vma
 830        + (*sa)->target_section->output_offset
 831        + (*sa)->target_off
 832        - (*sb)->target_section->output_section->vma
 833        - (*sb)->target_section->output_offset
 834        - (*sb)->target_off);
 835   if (d != 0)
 836     return d < 0 ? -1 : 1;
 837
 838   /* Two functions at the same address.  Aliases perhaps.  */
 839   i = strcmp ((*sb)->root.string, (*sa)->root.string);
 840   BFD_ASSERT (i != 0);
 841   return i;
 842 }
 843
 844 /* Allocate space for overlay call and return stubs.  */
 845
 846 bfd_boolean
 847 spu_elf_size_stubs (bfd *output_bfd,
 848                     struct bfd_link_info *info,
 849                     int non_overlay_stubs,
 850                     int stack_analysis,
 851                     asection **stub,
 852                     asection **ovtab,
 853                     asection **toe)
 854 {
 855   struct spu_link_hash_table *htab = spu_hash_table (info);
 856   bfd *ibfd;
 857   struct stubarr stubs;
 858   unsigned i, group;
 859   flagword flags;
 860
 861   htab->non_overlay_stubs = non_overlay_stubs;
 862   stubs.stub_hash_table = &htab->stub_hash_table;
 863   stubs.count = 0;
 864   stubs.err = 0;
 865   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
 866     {
 867       extern const bfd_target bfd_elf32_spu_vec;
 868       Elf_Internal_Shdr *symtab_hdr;
 869       asection *section;
 870       Elf_Internal_Sym *local_syms = NULL;
 871       void *psyms;
 872
 873       if (ibfd->xvec != &bfd_elf32_spu_vec)
 874         continue;
 875
 876       /* We'll need the symbol table in a second.  */
 877       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
 878       if (symtab_hdr->sh_info == 0)
 879         continue;
 880
 881       /* Arrange to read and keep global syms for later stack analysis.  */
 882       psyms = &local_syms;
 883       if (stack_analysis)
 884         psyms = &symtab_hdr->contents;
 885
 886       /* Walk over each section attached to the input bfd.  */
 887       for (section = ibfd->sections; section != NULL; section = section->next)
 888         {
 889           Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
 890
 891           /* If there aren't any relocs, then there's nothing more to do.  */
 892           if ((section->flags & SEC_RELOC) == 0
 893               || (section->flags & SEC_ALLOC) == 0
 894               || (section->flags & SEC_LOAD) == 0
 895               || section->reloc_count == 0)
 896             continue;
 897
 898           /* If this section is a link-once section that will be
 899              discarded, then don't create any stubs.  */
 900           if (section->output_section == NULL
 901               || section->output_section->owner != output_bfd)
 902             continue;
 903
 904           /* Get the relocs.  */
 905           internal_relocs
 906             = _bfd_elf_link_read_relocs (ibfd, section, NULL, NULL,
 907                                          info->keep_memory);
 908           if (internal_relocs == NULL)
 909             goto error_ret_free_local;
 910
 911           /* Now examine each relocation.  */
 912           irela = internal_relocs;
 913           irelaend = irela + section->reloc_count;
 914           for (; irela < irelaend; irela++)
 915             {
 916               enum elf_spu_reloc_type r_type;
 917               unsigned int r_indx;
 918               asection *sym_sec;
 919               Elf_Internal_Sym *sym;
 920               struct elf_link_hash_entry *h;
 921               const char *sym_name;
 922               char *stub_name;
 923               struct spu_stub_hash_entry *sh;
 924               unsigned int sym_type;
 925               enum _insn_type { non_branch, branch, call } insn_type;
 926
 927               r_type = ELF32_R_TYPE (irela->r_info);
 928               r_indx = ELF32_R_SYM (irela->r_info);
 929
 930               if (r_type >= R_SPU_max)
 931                 {
 932                   bfd_set_error (bfd_error_bad_value);
 933                   goto error_ret_free_internal;
 934                 }
 935
 936               /* Determine the reloc target section.  */
 937               if (!get_sym_h (&h, &sym, &sym_sec, psyms, r_indx, ibfd))
 938                 goto error_ret_free_internal;
 939
 940               if (sym_sec == NULL
 941                   || sym_sec->output_section == NULL
 942                   || sym_sec->output_section->owner != output_bfd)
 943                 continue;
 944
 945               /* Ensure no stubs for user supplied overlay manager syms.  */
 946               if (h != NULL
 947                   && (strcmp (h->root.root.string, "__ovly_load") == 0
 948                       || strcmp (h->root.root.string, "__ovly_return") == 0))
 949                 continue;
 950
 951               insn_type = non_branch;
 952               if (r_type == R_SPU_REL16
 953                   || r_type == R_SPU_ADDR16)
 954                 {
 955                   unsigned char insn[4];
 956
 957                   if (!bfd_get_section_contents (ibfd, section, insn,
 958                                                  irela->r_offset, 4))
 959                     goto error_ret_free_internal;
 960
 961                   if (is_branch (insn) || is_hint (insn))
 962                     {
 963                       insn_type = branch;
 964                       if ((insn[0] & 0xfd) == 0x31)
 965                         insn_type = call;
 966                     }
 967                 }
 968
 969               /* We are only interested in function symbols.  */
 970               if (h != NULL)
 971                 {
 972                   sym_type = h->type;
 973                   sym_name = h->root.root.string;
 974                 }
 975               else
 976                 {
 977                   sym_type = ELF_ST_TYPE (sym->st_info);
 978                   sym_name = bfd_elf_sym_name (sym_sec->owner,
 979                                                symtab_hdr,
 980                                                sym,
 981                                                sym_sec);
 982                 }
 983               if (sym_type != STT_FUNC)
 984                 {
 985                   /* It's common for people to write assembly and forget
 986                      to give function symbols the right type.  Handle
 987                      calls to such symbols, but warn so that (hopefully)
 988                      people will fix their code.  We need the symbol
 989                      type to be correct to distinguish function pointer
 990                      initialisation from other pointer initialisation.  */
 991                   if (insn_type == call)
 992                     (*_bfd_error_handler) (_("warning: call to non-function"
 993                                              " symbol %s defined in %B"),
 994                                            sym_sec->owner, sym_name);
 995                   else
 996                     continue;
 997                 }
 998
 999               if (!needs_ovl_stub (sym_name, sym_sec, section, htab,
1000                                    insn_type != non_branch))
1001                 continue;
1002
1003               stub_name = spu_stub_name (sym_sec, h, irela);
1004               if (stub_name == NULL)
1005                 goto error_ret_free_internal;
1006
1007               sh = (struct spu_stub_hash_entry *)
1008                 bfd_hash_lookup (&htab->stub_hash_table, stub_name,
1009                                  TRUE, FALSE);
1010               if (sh == NULL)
1011                 {
1012                   free (stub_name);
1013                 error_ret_free_internal:
1014                   if (elf_section_data (section)->relocs != internal_relocs)
1015                     free (internal_relocs);
1016                 error_ret_free_local:
1017                   if (local_syms != NULL
1018                       && (symtab_hdr->contents
1019                           != (unsigned char *) local_syms))
1020                     free (local_syms);
1021                   return FALSE;
1022                 }
1023
1024               /* If this entry isn't new, we already have a stub.  */
1025               if (sh->target_section != NULL)
1026                 {
1027                   free (stub_name);
1028                   continue;
1029                 }
1030
1031               sh->target_section = sym_sec;
1032               if (h != NULL)
1033                 sh->target_off = h->root.u.def.value;
1034               else
1035                 sh->target_off = sym->st_value;
1036               sh->target_off += irela->r_addend;
1037
1038               stubs.count += 1;
1039             }
1040
1041           /* We're done with the internal relocs, free them.  */
1042           if (elf_section_data (section)->relocs != internal_relocs)
1043             free (internal_relocs);
1044         }
1045
1046       if (local_syms != NULL
1047           && symtab_hdr->contents != (unsigned char *) local_syms)
1048         {
1049           if (!info->keep_memory)
1050             free (local_syms);
1051           else
1052             symtab_hdr->contents = (unsigned char *) local_syms;
1053         }
1054     }
1055
1056   elf_link_hash_traverse (&htab->elf, allocate_spuear_stubs, &stubs);
1057   if (stubs.err)
1058     return FALSE;
1059
1060   *stub = NULL;
1061   if (stubs.count == 0)
1062     return TRUE;
1063
1064   ibfd = info->input_bfds;
1065   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
1066            | SEC_HAS_CONTENTS | SEC_IN_MEMORY);
1067   htab->stub = bfd_make_section_anyway_with_flags (ibfd, ".stub", flags);
1068   *stub = htab->stub;
1069   if (htab->stub == NULL
1070       || !bfd_set_section_alignment (ibfd, htab->stub, 2))
1071     return FALSE;
1072
1073   flags = (SEC_ALLOC | SEC_LOAD
1074            | SEC_HAS_CONTENTS | SEC_IN_MEMORY);
1075   htab->ovtab = bfd_make_section_anyway_with_flags (ibfd, ".ovtab", flags);
1076   *ovtab = htab->ovtab;
1077   if (htab->ovtab == NULL
1078       || !bfd_set_section_alignment (ibfd, htab->stub, 4))
1079     return FALSE;
1080
1081   *toe = bfd_make_section_anyway_with_flags (ibfd, ".toe", SEC_ALLOC);
1082   if (*toe == NULL
1083       || !bfd_set_section_alignment (ibfd, *toe, 4))
1084     return FALSE;
1085   (*toe)->size = 16;
1086
1087   /* Retrieve all the stubs and sort.  */
1088   stubs.sh = bfd_malloc (stubs.count * sizeof (*stubs.sh));
1089   if (stubs.sh == NULL)
1090     return FALSE;
1091   i = stubs.count;
1092   bfd_hash_traverse (&htab->stub_hash_table, populate_stubs, &stubs);
1093   BFD_ASSERT (stubs.count == 0);
1094
1095   stubs.count = i;
1096   qsort (stubs.sh, stubs.count, sizeof (*stubs.sh), sort_stubs);
1097
1098   /* Now that the stubs are sorted, place them in the stub section.
1099      Stubs are grouped per overlay
1100      .      ila $79,func1
1101      .      br 1f
1102      .      ila $79,func2
1103      .      br 1f
1104      .
1105      .
1106      .      ila $79,funcn
1107      .      nop
1108      .  1:
1109      .      ila $78,ovl_index
1110      .      br __ovly_load  */
1111
1112   group = 0;
1113   for (i = 0; i < stubs.count; i++)
1114     {
1115       if (spu_elf_section_data (stubs.sh[group]->target_section
1116                                 ->output_section)->ovl_index
1117           != spu_elf_section_data (stubs.sh[i]->target_section
1118                                    ->output_section)->ovl_index)
1119         {
1120           htab->stub->size += SIZEOF_STUB2;
1121           for (; group != i; group++)
1122             stubs.sh[group]->delta
1123               = stubs.sh[i - 1]->off - stubs.sh[group]->off;
1124         }
1125       if (group == i
1126           || ((stubs.sh[i - 1]->target_section->output_section->vma
1127                + stubs.sh[i - 1]->target_section->output_offset
1128                + stubs.sh[i - 1]->target_off)
1129               != (stubs.sh[i]->target_section->output_section->vma
1130                   + stubs.sh[i]->target_section->output_offset
1131                   + stubs.sh[i]->target_off)))
1132         {
1133           stubs.sh[i]->off = htab->stub->size;
1134           htab->stub->size += SIZEOF_STUB1;
1135         }
1136       else
1137         stubs.sh[i]->off = stubs.sh[i - 1]->off;
1138     }
1139   if (group != i)
1140     htab->stub->size += SIZEOF_STUB2;
1141   for (; group != i; group++)
1142     stubs.sh[group]->delta = stubs.sh[i - 1]->off - stubs.sh[group]->off;
1143
1144  /* htab->ovtab consists of two arrays.
1145     .   struct {
1146     .     u32 vma;
1147     .     u32 size;
1148     .     u32 file_off;
1149     .     u32 buf;
1150     .   } _ovly_table[];
1151     .
1152     .   struct {
1153     .     u32 mapped;
1154     .   } _ovly_buf_table[];  */
1155
1156   htab->ovtab->alignment_power = 4;
1157   htab->ovtab->size = htab->num_overlays * 16 + htab->num_buf * 4;
1158
1159   return TRUE;
1160 }
1161
1162 /* Functions to handle embedded spu_ovl.o object.  */
1163
1164 static void *
1165 ovl_mgr_open (struct bfd *nbfd ATTRIBUTE_UNUSED, void *stream)
1166 {
1167   return stream;
1168 }
1169
1170 static file_ptr
1171 ovl_mgr_pread (struct bfd *abfd ATTRIBUTE_UNUSED,
1172                void *stream,
1173                void *buf,
1174                file_ptr nbytes,
1175                file_ptr offset)
1176 {
1177   struct _ovl_stream *os;
1178   size_t count;
1179   size_t max;
1180
1181   os = (struct _ovl_stream *) stream;
1182   max = (const char *) os->end - (const char *) os->start;
1183
1184   if ((ufile_ptr) offset >= max)
1185     return 0;
1186
1187   count = nbytes;
1188   if (count > max - offset)
1189     count = max - offset;
1190
1191   memcpy (buf, (const char *) os->start + offset, count);
1192   return count;
1193 }
1194
1195 bfd_boolean
1196 spu_elf_open_builtin_lib (bfd **ovl_bfd, const struct _ovl_stream *stream)
1197 {
1198   *ovl_bfd = bfd_openr_iovec ("builtin ovl_mgr",
1199                               "elf32-spu",
1200                               ovl_mgr_open,
1201                               (void *) stream,
1202                               ovl_mgr_pread,
1203                               NULL,
1204                               NULL);
1205   return *ovl_bfd != NULL;
1206 }
1207
1208 /* Fill in the ila and br for a stub.  On the last stub for a group,
1209    write the stub that sets the overlay number too.  */
1210
1211 static bfd_boolean
1212 write_one_stub (struct bfd_hash_entry *bh, void *inf)
1213 {
1214   struct spu_stub_hash_entry *ent = (struct spu_stub_hash_entry *) bh;
1215   struct spu_link_hash_table *htab = inf;
1216   asection *sec = htab->stub;
1217   asection *s = ent->target_section;
1218   unsigned int ovl;
1219   bfd_vma val;
1220
1221   val = ent->target_off + s->output_offset + s->output_section->vma;
1222   bfd_put_32 (sec->owner, ILA_79 + ((val << 7) & 0x01ffff80),
1223               sec->contents + ent->off);
1224   val = ent->delta + 4;
1225   bfd_put_32 (sec->owner, BR + ((val << 5) & 0x007fff80),
1226               sec->contents + ent->off + 4);
1227
1228   /* If this is the last stub of this group, write stub2.  */
1229   if (ent->delta == 0)
1230     {
1231       bfd_put_32 (sec->owner, NOP,
1232                   sec->contents + ent->off + 4);
1233
1234       ovl = spu_elf_section_data (s->output_section)->ovl_index;
1235       bfd_put_32 (sec->owner, ILA_78 + ((ovl << 7) & 0x01ffff80),
1236                   sec->contents + ent->off + 8);
1237
1238       val = (htab->ovly_load->root.u.def.section->output_section->vma
1239              + htab->ovly_load->root.u.def.section->output_offset
1240              + htab->ovly_load->root.u.def.value
1241              - (sec->output_section->vma
1242                 + sec->output_offset
1243                 + ent->off + 12));
1244
1245       if (val + 0x20000 >= 0x40000)
1246         htab->stub_overflow = TRUE;
1247
1248       bfd_put_32 (sec->owner, BR + ((val << 5) & 0x007fff80),
1249                   sec->contents + ent->off + 12);
1250     }
1251
1252   if (htab->emit_stub_syms)
1253     {
1254       struct elf_link_hash_entry *h;
1255       size_t len1, len2;
1256       char *name;
1257
1258       len1 = sizeof ("00000000.ovl_call.") - 1;
1259       len2 = strlen (ent->root.string);
1260       name = bfd_malloc (len1 + len2 + 1);
1261       if (name == NULL)
1262         return FALSE;
1263       memcpy (name, "00000000.ovl_call.", len1);
1264       memcpy (name + len1, ent->root.string, len2 + 1);
1265       h = elf_link_hash_lookup (&htab->elf, name, TRUE, TRUE, FALSE);
1266       free (name);
1267       if (h == NULL)
1268         return FALSE;
1269       if (h->root.type == bfd_link_hash_new)
1270         {
1271           h->root.type = bfd_link_hash_defined;
1272           h->root.u.def.section = sec;
1273           h->root.u.def.value = ent->off;
1274           h->size = (ent->delta == 0
1275                      ? SIZEOF_STUB1 + SIZEOF_STUB2 : SIZEOF_STUB1);
1276           h->type = STT_FUNC;
1277           h->ref_regular = 1;
1278           h->def_regular = 1;
1279           h->ref_regular_nonweak = 1;
1280           h->forced_local = 1;
1281           h->non_elf = 0;
1282         }
1283     }
1284
1285   return TRUE;
1286 }
1287
1288 /* Define an STT_OBJECT symbol.  */
1289
1290 static struct elf_link_hash_entry *
1291 define_ovtab_symbol (struct spu_link_hash_table *htab, const char *name)
1292 {
1293   struct elf_link_hash_entry *h;
1294
1295   h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
1296   if (h == NULL)
1297     return NULL;
1298
1299   if (h->root.type != bfd_link_hash_defined
1300       || !h->def_regular)
1301     {
1302       h->root.type = bfd_link_hash_defined;
1303       h->root.u.def.section = htab->ovtab;
1304       h->type = STT_OBJECT;
1305       h->ref_regular = 1;
1306       h->def_regular = 1;
1307       h->ref_regular_nonweak = 1;
1308       h->non_elf = 0;
1309     }
1310   else
1311     {
1312       (*_bfd_error_handler) (_("%B is not allowed to define %s"),
1313                              h->root.u.def.section->owner,
1314                              h->root.root.string);
1315       bfd_set_error (bfd_error_bad_value);
1316       return NULL;
1317     }
1318
1319   return h;
1320 }
1321
1322 /* Fill in all stubs and the overlay tables.  */
1323
1324 bfd_boolean
1325 spu_elf_build_stubs (struct bfd_link_info *info, int emit_syms, asection *toe)
1326 {
1327   struct spu_link_hash_table *htab = spu_hash_table (info);
1328   struct elf_link_hash_entry *h;
1329   bfd_byte *p;
1330   asection *s;
1331   bfd *obfd;
1332   unsigned int i;
1333
1334   htab->emit_stub_syms = emit_syms;
1335   htab->stub->contents = bfd_zalloc (htab->stub->owner, htab->stub->size);
1336   if (htab->stub->contents == NULL)
1337     return FALSE;
1338
1339   h = elf_link_hash_lookup (&htab->elf, "__ovly_load", FALSE, FALSE, FALSE);
1340   htab->ovly_load = h;
1341   BFD_ASSERT (h != NULL
1342               && (h->root.type == bfd_link_hash_defined
1343                   || h->root.type == bfd_link_hash_defweak)
1344               && h->def_regular);
1345
1346   s = h->root.u.def.section->output_section;
1347   if (spu_elf_section_data (s)->ovl_index)
1348     {
1349       (*_bfd_error_handler) (_("%s in overlay section"),
1350                              h->root.u.def.section->owner);
1351       bfd_set_error (bfd_error_bad_value);
1352       return FALSE;
1353     }
1354
1355   /* Write out all the stubs.  */
1356   bfd_hash_traverse (&htab->stub_hash_table, write_one_stub, htab);
1357
1358   if (htab->stub_overflow)
1359     {
1360       (*_bfd_error_handler) (_("overlay stub relocation overflow"));
1361       bfd_set_error (bfd_error_bad_value);
1362       return FALSE;
1363     }
1364
1365   htab->ovtab->contents = bfd_zalloc (htab->ovtab->owner, htab->ovtab->size);
1366   if (htab->ovtab->contents == NULL)
1367     return FALSE;
1368
1369   /* Write out _ovly_table.  */
1370   p = htab->ovtab->contents;
1371   obfd = htab->ovtab->output_section->owner;
1372   for (s = obfd->sections; s != NULL; s = s->next)
1373     {
1374       unsigned int ovl_index = spu_elf_section_data (s)->ovl_index;
1375
1376       if (ovl_index != 0)
1377         {
1378           unsigned int lo, hi, mid;
1379           unsigned long off = (ovl_index - 1) * 16;
1380           bfd_put_32 (htab->ovtab->owner, s->vma, p + off);
1381           bfd_put_32 (htab->ovtab->owner, (s->size + 15) & -16, p + off + 4);
1382           /* file_off written later in spu_elf_modify_program_headers.  */
1383
1384           lo = 0;
1385           hi = htab->num_buf;
1386           while (lo < hi)
1387             {
1388               mid = (lo + hi) >> 1;
1389               if (htab->ovl_region[2 * mid + 1]->vma
1390                   + htab->ovl_region[2 * mid + 1]->size <= s->vma)
1391                 lo = mid + 1;
1392               else if (htab->ovl_region[2 * mid]->vma > s->vma)
1393                 hi = mid;
1394               else
1395                 {
1396                   bfd_put_32 (htab->ovtab->owner, mid + 1, p + off + 12);
1397                   break;
1398                 }
1399             }
1400           BFD_ASSERT (lo < hi);
1401         }
1402     }
1403
1404   /* Write out _ovly_buf_table.  */
1405   p = htab->ovtab->contents + htab->num_overlays * 16;
1406   for (i = 0; i < htab->num_buf; i++)
1407     {
1408       bfd_put_32 (htab->ovtab->owner, 0, p);
1409       p += 4;
1410     }
1411
1412   h = define_ovtab_symbol (htab, "_ovly_table");
1413   if (h == NULL)
1414     return FALSE;
1415   h->root.u.def.value = 0;
1416   h->size = htab->num_overlays * 16;
1417
1418   h = define_ovtab_symbol (htab, "_ovly_table_end");
1419   if (h == NULL)
1420     return FALSE;
1421   h->root.u.def.value = htab->num_overlays * 16;
1422   h->size = 0;
1423
1424   h = define_ovtab_symbol (htab, "_ovly_buf_table");
1425   if (h == NULL)
1426     return FALSE;
1427   h->root.u.def.value = htab->num_overlays * 16;
1428   h->size = htab->num_buf * 4;
1429
1430   h = define_ovtab_symbol (htab, "_ovly_buf_table_end");
1431   if (h == NULL)
1432     return FALSE;
1433   h->root.u.def.value = htab->num_overlays * 16 + htab->num_buf * 4;
1434   h->size = 0;
1435
1436   h = define_ovtab_symbol (htab, "_EAR_");
1437   if (h == NULL)
1438     return FALSE;
1439   h->root.u.def.section = toe;
1440   h->root.u.def.value = 0;
1441   h->size = 16;
1442
1443   return TRUE;
1444 }
1445
1446 /* OFFSET in SEC (presumably) is the beginning of a function prologue.
1447    Search for stack adjusting insns, and return the sp delta.  */
1448
1449 static int
1450 find_function_stack_adjust (asection *sec, bfd_vma offset)
1451 {
1452   int unrecog;
1453   int reg[128];
1454
1455   memset (reg, 0, sizeof (reg));
1456   for (unrecog = 0; offset + 4 <= sec->size && unrecog < 32; offset += 4)
1457     {
1458       unsigned char buf[4];
1459       int rt, ra;
1460       int imm;
1461
1462       /* Assume no relocs on stack adjusing insns.  */
1463       if (!bfd_get_section_contents (sec->owner, sec, buf, offset, 4))
1464         break;
1465
1466       if (buf[0] == 0x24 /* stqd */)
1467         continue;
1468
1469       rt = buf[3] & 0x7f;
1470       ra = ((buf[2] & 0x3f) << 1) | (buf[3] >> 7);
1471       /* Partly decoded immediate field.  */
1472       imm = (buf[1] << 9) | (buf[2] << 1) | (buf[3] >> 7);
1473
1474       if (buf[0] == 0x1c /* ai */)
1475         {
1476           imm >>= 7;
1477           imm = (imm ^ 0x200) - 0x200;
1478           reg[rt] = reg[ra] + imm;
1479
1480           if (rt == 1 /* sp */)
1481             {
1482               if (imm > 0)
1483                 break;
1484               return reg[rt];
1485             }
1486         }
1487       else if (buf[0] == 0x18 && (buf[1] & 0xe0) == 0 /* a */)
1488         {
1489           int rb = ((buf[1] & 0x1f) << 2) | ((buf[2] & 0xc0) >> 6);
1490
1491           reg[rt] = reg[ra] + reg[rb];
1492           if (rt == 1)
1493             return reg[rt];
1494         }
1495       else if ((buf[0] & 0xfc) == 0x40 /* il, ilh, ilhu, ila */)
1496         {
1497           if (buf[0] >= 0x42 /* ila */)
1498             imm |= (buf[0] & 1) << 17;
1499           else
1500             {
1501               imm &= 0xffff;
1502
1503               if (buf[0] == 0x40 /* il */)
1504                 {
1505                   if ((buf[1] & 0x80) == 0)
1506                     goto unknown_insn;
1507                   imm = (imm ^ 0x8000) - 0x8000;
1508                 }
1509               else if ((buf[1] & 0x80) == 0 /* ilhu */)
1510                 imm <<= 16;
1511             }
1512           reg[rt] = imm;
1513           continue;
1514         }
1515       else if (buf[0] == 0x60 && (buf[1] & 0x80) != 0 /* iohl */)
1516         {
1517           reg[rt] |= imm & 0xffff;
1518           continue;
1519         }
1520       else if (buf[0] == 0x04 /* ori */)
1521         {
1522           imm >>= 7;
1523           imm = (imm ^ 0x200) - 0x200;
1524           reg[rt] = reg[ra] | imm;
1525           continue;
1526         }
1527       else if ((buf[0] == 0x33 && imm == 1 /* brsl .+4 */)
1528                || (buf[0] == 0x08 && (buf[1] & 0xe0) == 0 /* sf */))
1529         {
1530           /* Used in pic reg load.  Say rt is trashed.  */
1531           reg[rt] = 0;
1532           continue;
1533         }
1534       else if (is_branch (buf))
1535         /* If we hit a branch then we must be out of the prologue.  */
1536         break;
1537     unknown_insn:
1538       ++unrecog;
1539     }
1540
1541   return 0;
1542 }
1543
1544 /* qsort predicate to sort symbols by section and value.  */
1545
1546 static Elf_Internal_Sym *sort_syms_syms;
1547 static asection **sort_syms_psecs;
1548
1549 static int
1550 sort_syms (const void *a, const void *b)
1551 {
1552   Elf_Internal_Sym *const *s1 = a;
1553   Elf_Internal_Sym *const *s2 = b;
1554   asection *sec1,*sec2;
1555   bfd_signed_vma delta;
1556
1557   sec1 = sort_syms_psecs[*s1 - sort_syms_syms];
1558   sec2 = sort_syms_psecs[*s2 - sort_syms_syms];
1559
1560   if (sec1 != sec2)
1561     return sec1->index - sec2->index;
1562
1563   delta = (*s1)->st_value - (*s2)->st_value;
1564   if (delta != 0)
1565     return delta < 0 ? -1 : 1;
1566
1567   delta = (*s2)->st_size - (*s1)->st_size;
1568   if (delta != 0)
1569     return delta < 0 ? -1 : 1;
1570
1571   return *s1 < *s2 ? -1 : 1;
1572 }
1573
1574 struct call_info
1575 {
1576   struct function_info *fun;
1577   struct call_info *next;
1578   int is_tail;
1579 };
1580
1581 struct function_info
1582 {
1583   /* List of functions called.  Also branches to hot/cold part of
1584      function.  */
1585   struct call_info *call_list;
1586   /* For hot/cold part of function, point to owner.  */
1587   struct function_info *start;
1588   /* Symbol at start of function.  */
1589   union {
1590     Elf_Internal_Sym *sym;
1591     struct elf_link_hash_entry *h;
1592   } u;
1593   /* Function section.  */
1594   asection *sec;
1595   /* Address range of (this part of) function.  */
1596   bfd_vma lo, hi;
1597   /* Stack usage.  */
1598   int stack;
1599   /* Set if global symbol.  */
1600   unsigned int global : 1;
1601   /* Set if known to be start of function (as distinct from a hunk
1602      in hot/cold section.  */
1603   unsigned int is_func : 1;
1604   /* Flags used during call tree traversal.  */
1605   unsigned int visit1 : 1;
1606   unsigned int non_root : 1;
1607   unsigned int visit2 : 1;
1608   unsigned int marking : 1;
1609   unsigned int visit3 : 1;
1610 };
1611
1612 struct spu_elf_stack_info
1613 {
1614   int num_fun;
1615   int max_fun;
1616   /* Variable size array describing functions, one per contiguous
1617      address range belonging to a function.  */
1618   struct function_info fun[1];
1619 };
1620
1621 /* Allocate a struct spu_elf_stack_info with MAX_FUN struct function_info
1622    entries for section SEC.  */
1623
1624 static struct spu_elf_stack_info *
1625 alloc_stack_info (asection *sec, int max_fun)
1626 {
1627   struct _spu_elf_section_data *sec_data = spu_elf_section_data (sec);
1628   bfd_size_type amt;
1629
1630   amt = sizeof (struct spu_elf_stack_info);
1631   amt += (max_fun - 1) * sizeof (struct function_info);
1632   sec_data->stack_info = bfd_zmalloc (amt);
1633   if (sec_data->stack_info != NULL)
1634     sec_data->stack_info->max_fun = max_fun;
1635   return sec_data->stack_info;
1636 }
1637
1638 /* Add a new struct function_info describing a (part of a) function
1639    starting at SYM_H.  Keep the array sorted by address.  */
1640
1641 static struct function_info *
1642 maybe_insert_function (asection *sec,
1643                        void *sym_h,
1644                        bfd_boolean global,
1645                        bfd_boolean is_func)
1646 {
1647   struct _spu_elf_section_data *sec_data = spu_elf_section_data (sec);
1648   struct spu_elf_stack_info *sinfo = sec_data->stack_info;
1649   int i;
1650   bfd_vma off, size;
1651
1652   if (sinfo == NULL)
1653     {
1654       sinfo = alloc_stack_info (sec, 20);
1655       if (sinfo == NULL)
1656         return NULL;
1657     }
1658
1659   if (!global)
1660     {
1661       Elf_Internal_Sym *sym = sym_h;
1662       off = sym->st_value;
1663       size = sym->st_size;
1664     }
1665   else
1666     {
1667       struct elf_link_hash_entry *h = sym_h;
1668       off = h->root.u.def.value;
1669       size = h->size;
1670     }
1671
1672   for (i = sinfo->num_fun; --i >= 0; )
1673     if (sinfo->fun[i].lo <= off)
1674       break;
1675
1676   if (i >= 0)
1677     {
1678       /* Don't add another entry for an alias, but do update some
1679          info.  */
1680       if (sinfo->fun[i].lo == off)
1681         {
1682           /* Prefer globals over local syms.  */
1683           if (global && !sinfo->fun[i].global)
1684             {
1685               sinfo->fun[i].global = TRUE;
1686               sinfo->fun[i].u.h = sym_h;
1687             }
1688           if (is_func)
1689             sinfo->fun[i].is_func = TRUE;
1690           return &sinfo->fun[i];
1691         }
1692       /* Ignore a zero-size symbol inside an existing function.  */
1693       else if (sinfo->fun[i].hi > off && size == 0)
1694         return &sinfo->fun[i];
1695     }
1696
1697   if (++i < sinfo->num_fun)
1698     memmove (&sinfo->fun[i + 1], &sinfo->fun[i],
1699              (sinfo->num_fun - i) * sizeof (sinfo->fun[i]));
1700   else if (i >= sinfo->max_fun)
1701     {
1702       bfd_size_type amt = sizeof (struct spu_elf_stack_info);
1703       bfd_size_type old = amt;
1704
1705       old += (sinfo->max_fun - 1) * sizeof (struct function_info);
1706       sinfo->max_fun += 20 + (sinfo->max_fun >> 1);
1707       amt += (sinfo->max_fun - 1) * sizeof (struct function_info);
1708       sinfo = bfd_realloc (sinfo, amt);
1709       if (sinfo == NULL)
1710         return NULL;
1711       memset ((char *) sinfo + old, 0, amt - old);
1712       sec_data->stack_info = sinfo;
1713     }
1714   sinfo->fun[i].is_func = is_func;
1715   sinfo->fun[i].global = global;
1716   sinfo->fun[i].sec = sec;
1717   if (global)
1718     sinfo->fun[i].u.h = sym_h;
1719   else
1720     sinfo->fun[i].u.sym = sym_h;
1721   sinfo->fun[i].lo = off;
1722   sinfo->fun[i].hi = off + size;
1723   sinfo->fun[i].stack = -find_function_stack_adjust (sec, off);
1724   sinfo->num_fun += 1;
1725   return &sinfo->fun[i];
1726 }
1727
1728 /* Return the name of FUN.  */
1729
1730 static const char *
1731 func_name (struct function_info *fun)
1732 {
1733   asection *sec;
1734   bfd *ibfd;
1735   Elf_Internal_Shdr *symtab_hdr;
1736
1737   while (fun->start != NULL)
1738     fun = fun->start;
1739
1740   if (fun->global)
1741     return fun->u.h->root.root.string;
1742
1743   sec = fun->sec;
1744   if (fun->u.sym->st_name == 0)
1745     {
1746       size_t len = strlen (sec->name);
1747       char *name = bfd_malloc (len + 10);
1748       if (name == NULL)
1749         return "(null)";
1750       sprintf (name, "%s+%lx", sec->name,
1751                (unsigned long) fun->u.sym->st_value & 0xffffffff);
1752       return name;
1753     }
1754   ibfd = sec->owner;
1755   symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
1756   return bfd_elf_sym_name (ibfd, symtab_hdr, fun->u.sym, sec);
1757 }
1758
1759 /* Read the instruction at OFF in SEC.  Return true iff the instruction
1760    is a nop, lnop, or stop 0 (all zero insn).  */
1761
1762 static bfd_boolean
1763 is_nop (asection *sec, bfd_vma off)
1764 {
1765   unsigned char insn[4];
1766
1767   if (off + 4 > sec->size
1768       || !bfd_get_section_contents (sec->owner, sec, insn, off, 4))
1769     return FALSE;
1770   if ((insn[0] & 0xbf) == 0 && (insn[1] & 0xe0) == 0x20)
1771     return TRUE;
1772   if (insn[0] == 0 && insn[1] == 0 && insn[2] == 0 && insn[3] == 0)
1773     return TRUE;
1774   return FALSE;
1775 }
1776
1777 /* Extend the range of FUN to cover nop padding up to LIMIT.
1778    Return TRUE iff some instruction other than a NOP was found.  */
1779
1780 static bfd_boolean
1781 insns_at_end (struct function_info *fun, bfd_vma limit)
1782 {
1783   bfd_vma off = (fun->hi + 3) & -4;
1784
1785   while (off < limit && is_nop (fun->sec, off))
1786     off += 4;
1787   if (off < limit)
1788     {
1789       fun->hi = off;
1790       return TRUE;
1791     }
1792   fun->hi = limit;
1793   return FALSE;
1794 }
1795
1796 /* Check and fix overlapping function ranges.  Return TRUE iff there
1797    are gaps in the current info we have about functions in SEC.  */
1798
1799 static bfd_boolean
1800 check_function_ranges (asection *sec, struct bfd_link_info *info)
1801 {
1802   struct _spu_elf_section_data *sec_data = spu_elf_section_data (sec);
1803   struct spu_elf_stack_info *sinfo = sec_data->stack_info;
1804   int i;
1805   bfd_boolean gaps = FALSE;
1806
1807   if (sinfo == NULL)
1808     return FALSE;
1809
1810   for (i = 1; i < sinfo->num_fun; i++)
1811     if (sinfo->fun[i - 1].hi > sinfo->fun[i].lo)
1812       {
1813         /* Fix overlapping symbols.  */
1814         const char *f1 = func_name (&sinfo->fun[i - 1]);
1815         const char *f2 = func_name (&sinfo->fun[i]);
1816
1817         info->callbacks->einfo (_("warning: %s overlaps %s\n"), f1, f2);
1818         sinfo->fun[i - 1].hi = sinfo->fun[i].lo;
1819       }
1820     else if (insns_at_end (&sinfo->fun[i - 1], sinfo->fun[i].lo))
1821       gaps = TRUE;
1822
1823   if (sinfo->num_fun == 0)
1824     gaps = TRUE;
1825   else
1826     {
1827       if (sinfo->fun[0].lo != 0)
1828         gaps = TRUE;
1829       if (sinfo->fun[sinfo->num_fun - 1].hi > sec->size)
1830         {
1831           const char *f1 = func_name (&sinfo->fun[sinfo->num_fun - 1]);
1832
1833           info->callbacks->einfo (_("warning: %s exceeds section size\n"), f1);
1834           sinfo->fun[sinfo->num_fun - 1].hi = sec->size;
1835         }
1836       else if (insns_at_end (&sinfo->fun[sinfo->num_fun - 1], sec->size))
1837         gaps = TRUE;
1838     }
1839   return gaps;
1840 }
1841
1842 /* Search current function info for a function that contains address
1843    OFFSET in section SEC.  */
1844
1845 static struct function_info *
1846 find_function (asection *sec, bfd_vma offset, struct bfd_link_info *info)
1847 {
1848   struct _spu_elf_section_data *sec_data = spu_elf_section_data (sec);
1849   struct spu_elf_stack_info *sinfo = sec_data->stack_info;
1850   int lo, hi, mid;
1851
1852   lo = 0;
1853   hi = sinfo->num_fun;
1854   while (lo < hi)
1855     {
1856       mid = (lo + hi) / 2;
1857       if (offset < sinfo->fun[mid].lo)
1858         hi = mid;
1859       else if (offset >= sinfo->fun[mid].hi)
1860         lo = mid + 1;
1861       else
1862         return &sinfo->fun[mid];
1863     }
1864   info->callbacks->einfo (_("%A:0x%v not found in function table\n"),
1865                           sec, offset);
1866   return NULL;
1867 }
1868
1869 /* Add CALLEE to CALLER call list if not already present.  */
1870
1871 static bfd_boolean
1872 insert_callee (struct function_info *caller, struct call_info *callee)
1873 {
1874   struct call_info *p;
1875   for (p = caller->call_list; p != NULL; p = p->next)
1876     if (p->fun == callee->fun)
1877       {
1878         /* Tail calls use less stack than normal calls.  Retain entry
1879            for normal call over one for tail call.  */
1880         if (p->is_tail > callee->is_tail)
1881           p->is_tail = callee->is_tail;
1882         return FALSE;
1883       }
1884   callee->next = caller->call_list;
1885   caller->call_list = callee;
1886   return TRUE;
1887 }
1888
1889 /* Rummage through the relocs for SEC, looking for function calls.
1890    If CALL_TREE is true, fill in call graph.  If CALL_TREE is false,
1891    mark destination symbols on calls as being functions.  Also
1892    look at branches, which may be tail calls or go to hot/cold
1893    section part of same function.  */
1894
1895 static bfd_boolean
1896 mark_functions_via_relocs (asection *sec,
1897                            struct bfd_link_info *info,
1898                            int call_tree)
1899 {
1900   Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
1901   Elf_Internal_Shdr *symtab_hdr = &elf_tdata (sec->owner)->symtab_hdr;
1902   Elf_Internal_Sym *syms;
1903   void *psyms;
1904   static bfd_boolean warned;
1905
1906   internal_relocs = _bfd_elf_link_read_relocs (sec->owner, sec, NULL, NULL,
1907                                                info->keep_memory);
1908   if (internal_relocs == NULL)
1909     return FALSE;
1910
1911   symtab_hdr = &elf_tdata (sec->owner)->symtab_hdr;
1912   psyms = &symtab_hdr->contents;
1913   syms = *(Elf_Internal_Sym **) psyms;
1914   irela = internal_relocs;
1915   irelaend = irela + sec->reloc_count;
1916   for (; irela < irelaend; irela++)
1917     {
1918       enum elf_spu_reloc_type r_type;
1919       unsigned int r_indx;
1920       asection *sym_sec;
1921       Elf_Internal_Sym *sym;
1922       struct elf_link_hash_entry *h;
1923       bfd_vma val;
1924       unsigned char insn[4];
1925       bfd_boolean is_call;
1926       struct function_info *caller;
1927       struct call_info *callee;
1928
1929       r_type = ELF32_R_TYPE (irela->r_info);
1930       if (r_type != R_SPU_REL16
1931           && r_type != R_SPU_ADDR16)
1932         continue;
1933
1934       r_indx = ELF32_R_SYM (irela->r_info);
1935       if (!get_sym_h (&h, &sym, &sym_sec, psyms, r_indx, sec->owner))
1936         return FALSE;
1937
1938       if (sym_sec == NULL
1939           || sym_sec->output_section == NULL
1940           || sym_sec->output_section->owner != sec->output_section->owner)
1941         continue;
1942
1943       if (!bfd_get_section_contents (sec->owner, sec, insn,
1944                                      irela->r_offset, 4))
1945         return FALSE;
1946       if (!is_branch (insn))
1947         continue;
1948
1949       if ((sym_sec->flags & (SEC_ALLOC | SEC_LOAD | SEC_CODE))
1950           != (SEC_ALLOC | SEC_LOAD | SEC_CODE))
1951         {
1952           if (!call_tree)
1953             warned = TRUE;
1954           if (!call_tree || !warned)
1955             info->callbacks->einfo (_("%B(%A+0x%v): call to non-code section"
1956                                       " %B(%A), stack analysis incomplete\n"),
1957                                     sec->owner, sec, irela->r_offset,
1958                                     sym_sec->owner, sym_sec);
1959           continue;
1960         }
1961
1962       is_call = (insn[0] & 0xfd) == 0x31;
1963
1964       if (h)
1965         val = h->root.u.def.value;
1966       else
1967         val = sym->st_value;
1968       val += irela->r_addend;
1969
1970       if (!call_tree)
1971         {
1972           struct function_info *fun;
1973
1974           if (irela->r_addend != 0)
1975             {
1976               Elf_Internal_Sym *fake = bfd_zmalloc (sizeof (*fake));
1977               if (fake == NULL)
1978                 return FALSE;
1979               fake->st_value = val;
1980               fake->st_shndx
1981                 = _bfd_elf_section_from_bfd_section (sym_sec->owner, sym_sec);
1982               sym = fake;
1983             }
1984           if (sym)
1985             fun = maybe_insert_function (sym_sec, sym, FALSE, is_call);
1986           else
1987             fun = maybe_insert_function (sym_sec, h, TRUE, is_call);
1988           if (fun == NULL)
1989             return FALSE;
1990           if (irela->r_addend != 0
1991               && fun->u.sym != sym)
1992             free (sym);
1993           continue;
1994         }
1995
1996       caller = find_function (sec, irela->r_offset, info);
1997       if (caller == NULL)
1998         return FALSE;
1999       callee = bfd_malloc (sizeof *callee);
2000       if (callee == NULL)
2001         return FALSE;
2002
2003       callee->fun = find_function (sym_sec, val, info);
2004       if (callee->fun == NULL)
2005         return FALSE;
2006       callee->is_tail = !is_call;
2007       if (!insert_callee (caller, callee))
2008         free (callee);
2009       else if (!is_call
2010                && !callee->fun->is_func
2011                && callee->fun->stack == 0)
2012         {
2013           /* This is either a tail call or a branch from one part of
2014              the function to another, ie. hot/cold section.  If the
2015              destination has been called by some other function then
2016              it is a separate function.  We also assume that functions
2017              are not split across input files.  */
2018           if (callee->fun->start != NULL
2019               || sec->owner != sym_sec->owner)
2020             {
2021               callee->fun->start = NULL;
2022               callee->fun->is_func = TRUE;
2023             }
2024           else
2025             callee->fun->start = caller;
2026         }
2027     }
2028
2029   return TRUE;
2030 }
2031
2032 /* Handle something like .init or .fini, which has a piece of a function.
2033    These sections are pasted together to form a single function.  */
2034
2035 static bfd_boolean
2036 pasted_function (asection *sec, struct bfd_link_info *info)
2037 {
2038   struct bfd_link_order *l;
2039   struct _spu_elf_section_data *sec_data;
2040   struct spu_elf_stack_info *sinfo;
2041   Elf_Internal_Sym *fake;
2042   struct function_info *fun, *fun_start;
2043
2044   fake = bfd_zmalloc (sizeof (*fake));
2045   if (fake == NULL)
2046     return FALSE;
2047   fake->st_value = 0;
2048   fake->st_size = sec->size;
2049   fake->st_shndx
2050     = _bfd_elf_section_from_bfd_section (sec->owner, sec);
2051   fun = maybe_insert_function (sec, fake, FALSE, FALSE);
2052   if (!fun)
2053     return FALSE;
2054
2055   /* Find a function immediately preceding this section.  */
2056   fun_start = NULL;
2057   for (l = sec->output_section->map_head.link_order; l != NULL; l = l->next)
2058     {
2059       if (l->u.indirect.section == sec)
2060         {
2061           if (fun_start != NULL)
2062             {
2063               if (fun_start->start)
2064                 fun_start = fun_start->start;
2065               fun->start = fun_start;
2066             }
2067           return TRUE;
2068         }
2069       if (l->type == bfd_indirect_link_order
2070           && (sec_data = spu_elf_section_data (l->u.indirect.section)) != NULL
2071           && (sinfo = sec_data->stack_info) != NULL
2072           && sinfo->num_fun != 0)
2073         fun_start = &sinfo->fun[sinfo->num_fun - 1];
2074     }
2075
2076   info->callbacks->einfo (_("%A link_order not found\n"), sec);
2077   return FALSE;
2078 }
2079
2080 /* We're only interested in code sections.  */
2081
2082 static bfd_boolean
2083 interesting_section (asection *s, bfd *obfd, struct spu_link_hash_table *htab)
2084 {
2085   return (s != htab->stub
2086           && s->output_section != NULL
2087           && s->output_section->owner == obfd
2088           && ((s->flags & (SEC_ALLOC | SEC_LOAD | SEC_CODE))
2089               == (SEC_ALLOC | SEC_LOAD | SEC_CODE))
2090           && s->size != 0);
2091 }
2092
2093 /* Map address ranges in code sections to functions.  */
2094
2095 static bfd_boolean
2096 discover_functions (bfd *output_bfd, struct bfd_link_info *info)
2097 {
2098   struct spu_link_hash_table *htab = spu_hash_table (info);
2099   bfd *ibfd;
2100   int bfd_idx;
2101   Elf_Internal_Sym ***psym_arr;
2102   asection ***sec_arr;
2103   bfd_boolean gaps = FALSE;
2104
2105   bfd_idx = 0;
2106   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2107     bfd_idx++;
2108
2109   psym_arr = bfd_zmalloc (bfd_idx * sizeof (*psym_arr));
2110   if (psym_arr == NULL)
2111     return FALSE;
2112   sec_arr = bfd_zmalloc (bfd_idx * sizeof (*sec_arr));
2113   if (sec_arr == NULL)
2114     return FALSE;
2115
2116
2117   for (ibfd = info->input_bfds, bfd_idx = 0;
2118        ibfd != NULL;
2119        ibfd = ibfd->link_next, bfd_idx++)
2120     {
2121       extern const bfd_target bfd_elf32_spu_vec;
2122       Elf_Internal_Shdr *symtab_hdr;
2123       asection *sec;
2124       size_t symcount;
2125       Elf_Internal_Sym *syms, *sy, **psyms, **psy;
2126       asection **psecs, **p;
2127
2128       if (ibfd->xvec != &bfd_elf32_spu_vec)
2129         continue;
2130
2131       /* Read all the symbols.  */
2132       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2133       symcount = symtab_hdr->sh_size / symtab_hdr->sh_entsize;
2134       if (symcount == 0)
2135         continue;
2136
2137       syms = (Elf_Internal_Sym *) symtab_hdr->contents;
2138       if (syms == NULL)
2139         {
2140           syms = bfd_elf_get_elf_syms (ibfd, symtab_hdr, symcount, 0,
2141                                        NULL, NULL, NULL);
2142           symtab_hdr->contents = (void *) syms;
2143           if (syms == NULL)
2144             return FALSE;
2145         }
2146
2147       /* Select defined function symbols that are going to be output.  */
2148       psyms = bfd_malloc ((symcount + 1) * sizeof (*psyms));
2149       if (psyms == NULL)
2150         return FALSE;
2151       psym_arr[bfd_idx] = psyms;
2152       psecs = bfd_malloc (symcount * sizeof (*psecs));
2153       if (psecs == NULL)
2154         return FALSE;
2155       sec_arr[bfd_idx] = psecs;
2156       for (psy = psyms, p = psecs, sy = syms; sy < syms + symcount; ++p, ++sy)
2157         if (ELF_ST_TYPE (sy->st_info) == STT_NOTYPE
2158             || ELF_ST_TYPE (sy->st_info) == STT_FUNC)
2159           {
2160             asection *s;
2161
2162             *p = s = bfd_section_from_elf_index (ibfd, sy->st_shndx);
2163             if (s != NULL && interesting_section (s, output_bfd, htab))
2164               *psy++ = sy;
2165           }
2166       symcount = psy - psyms;
2167       *psy = NULL;
2168
2169       /* Sort them by section and offset within section.  */
2170       sort_syms_syms = syms;
2171       sort_syms_psecs = psecs;
2172       qsort (psyms, symcount, sizeof (*psyms), sort_syms);
2173
2174       /* Now inspect the function symbols.  */
2175       for (psy = psyms; psy < psyms + symcount; )
2176         {
2177           asection *s = psecs[*psy - syms];
2178           Elf_Internal_Sym **psy2;
2179
2180           for (psy2 = psy; ++psy2 < psyms + symcount; )
2181             if (psecs[*psy2 - syms] != s)
2182               break;
2183
2184           if (!alloc_stack_info (s, psy2 - psy))
2185             return FALSE;
2186           psy = psy2;
2187         }
2188
2189       /* First install info about properly typed and sized functions.
2190          In an ideal world this will cover all code sections, except
2191          when partitioning functions into hot and cold sections,
2192          and the horrible pasted together .init and .fini functions.  */
2193       for (psy = psyms; psy < psyms + symcount; ++psy)
2194         {
2195           sy = *psy;
2196           if (ELF_ST_TYPE (sy->st_info) == STT_FUNC)
2197             {
2198               asection *s = psecs[sy - syms];
2199               if (!maybe_insert_function (s, sy, FALSE, TRUE))
2200                 return FALSE;
2201             }
2202         }
2203
2204       for (sec = ibfd->sections; sec != NULL && !gaps; sec = sec->next)
2205         if (interesting_section (sec, output_bfd, htab))
2206           gaps |= check_function_ranges (sec, info);
2207     }
2208
2209   if (gaps)
2210     {
2211       /* See if we can discover more function symbols by looking at
2212          relocations.  */
2213       for (ibfd = info->input_bfds, bfd_idx = 0;
2214            ibfd != NULL;
2215            ibfd = ibfd->link_next, bfd_idx++)
2216         {
2217           asection *sec;
2218
2219           if (psym_arr[bfd_idx] == NULL)
2220             continue;
2221
2222           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
2223             if (interesting_section (sec, output_bfd, htab)
2224                 && sec->reloc_count != 0)
2225               {
2226                 if (!mark_functions_via_relocs (sec, info, FALSE))
2227                   return FALSE;
2228               }
2229         }
2230
2231       for (ibfd = info->input_bfds, bfd_idx = 0;
2232            ibfd != NULL;
2233            ibfd = ibfd->link_next, bfd_idx++)
2234         {
2235           Elf_Internal_Shdr *symtab_hdr;
2236           asection *sec;
2237           Elf_Internal_Sym *syms, *sy, **psyms, **psy;
2238           asection **psecs;
2239
2240           if ((psyms = psym_arr[bfd_idx]) == NULL)
2241             continue;
2242
2243           psecs = sec_arr[bfd_idx];
2244
2245           symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2246           syms = (Elf_Internal_Sym *) symtab_hdr->contents;
2247
2248           gaps = FALSE;
2249           for (sec = ibfd->sections; sec != NULL && !gaps; sec = sec->next)
2250             if (interesting_section (sec, output_bfd, htab))
2251               gaps |= check_function_ranges (sec, info);
2252           if (!gaps)
2253             continue;
2254
2255           /* Finally, install all globals.  */
2256           for (psy = psyms; (sy = *psy) != NULL; ++psy)
2257             {
2258               asection *s;
2259
2260               s = psecs[sy - syms];
2261
2262               /* Global syms might be improperly typed functions.  */
2263               if (ELF_ST_TYPE (sy->st_info) != STT_FUNC
2264                   && ELF_ST_BIND (sy->st_info) == STB_GLOBAL)
2265                 {
2266                   if (!maybe_insert_function (s, sy, FALSE, FALSE))
2267                     return FALSE;
2268                 }
2269             }
2270
2271           /* Some of the symbols we've installed as marking the
2272              beginning of functions may have a size of zero.  Extend
2273              the range of such functions to the beginning of the
2274              next symbol of interest.  */
2275           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
2276             if (interesting_section (sec, output_bfd, htab))
2277               {
2278                 struct _spu_elf_section_data *sec_data;
2279                 struct spu_elf_stack_info *sinfo;
2280
2281                 sec_data = spu_elf_section_data (sec);
2282                 sinfo = sec_data->stack_info;
2283                 if (sinfo != NULL)
2284                   {
2285                     int fun_idx;
2286                     bfd_vma hi = sec->size;
2287
2288                     for (fun_idx = sinfo->num_fun; --fun_idx >= 0; )
2289                       {
2290                         sinfo->fun[fun_idx].hi = hi;
2291                         hi = sinfo->fun[fun_idx].lo;
2292                       }
2293                   }
2294                 /* No symbols in this section.  Must be .init or .fini
2295                    or something similar.  */
2296                 else if (!pasted_function (sec, info))
2297                   return FALSE;
2298               }
2299         }
2300     }
2301
2302   for (ibfd = info->input_bfds, bfd_idx = 0;
2303        ibfd != NULL;
2304        ibfd = ibfd->link_next, bfd_idx++)
2305     {
2306       if (psym_arr[bfd_idx] == NULL)
2307         continue;
2308
2309       free (psym_arr[bfd_idx]);
2310       free (sec_arr[bfd_idx]);
2311     }
2312
2313   free (psym_arr);
2314   free (sec_arr);
2315
2316   return TRUE;
2317 }
2318
2319 /* Mark nodes in the call graph that are called by some other node.  */
2320
2321 static void
2322 mark_non_root (struct function_info *fun)
2323 {
2324   struct call_info *call;
2325
2326   fun->visit1 = TRUE;
2327   for (call = fun->call_list; call; call = call->next)
2328     {
2329       call->fun->non_root = TRUE;
2330       if (!call->fun->visit1)
2331         mark_non_root (call->fun);
2332     }
2333 }
2334
2335 /* Remove cycles from the call graph.  */
2336
2337 static void
2338 call_graph_traverse (struct function_info *fun, struct bfd_link_info *info)
2339 {
2340   struct call_info **callp, *call;
2341
2342   fun->visit2 = TRUE;
2343   fun->marking = TRUE;
2344
2345   callp = &fun->call_list;
2346   while ((call = *callp) != NULL)
2347     {
2348       if (!call->fun->visit2)
2349         call_graph_traverse (call->fun, info);
2350       else if (call->fun->marking)
2351         {
2352           const char *f1 = func_name (fun);
2353           const char *f2 = func_name (call->fun);
2354
2355           info->callbacks->info (_("Stack analysis will ignore the call "
2356                                    "from %s to %s\n"),
2357                                  f1, f2);
2358           *callp = call->next;
2359           continue;
2360         }
2361       callp = &call->next;
2362     }
2363   fun->marking = FALSE;
2364 }
2365
2366 /* Populate call_list for each function.  */
2367
2368 static bfd_boolean
2369 build_call_tree (bfd *output_bfd, struct bfd_link_info *info)
2370 {
2371   struct spu_link_hash_table *htab = spu_hash_table (info);
2372   bfd *ibfd;
2373
2374   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2375     {
2376       extern const bfd_target bfd_elf32_spu_vec;
2377       asection *sec;
2378
2379       if (ibfd->xvec != &bfd_elf32_spu_vec)
2380         continue;
2381
2382       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
2383         {
2384           if (!interesting_section (sec, output_bfd, htab)
2385               || sec->reloc_count == 0)
2386             continue;
2387
2388           if (!mark_functions_via_relocs (sec, info, TRUE))
2389             return FALSE;
2390         }
2391
2392       /* Transfer call info from hot/cold section part of function
2393          to main entry.  */
2394       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
2395         {
2396           struct _spu_elf_section_data *sec_data;
2397           struct spu_elf_stack_info *sinfo;
2398
2399           if ((sec_data = spu_elf_section_data (sec)) != NULL
2400               && (sinfo = sec_data->stack_info) != NULL)
2401             {
2402               int i;
2403               for (i = 0; i < sinfo->num_fun; ++i)
2404                 {
2405                   if (sinfo->fun[i].start != NULL)
2406                     {
2407                       struct call_info *call = sinfo->fun[i].call_list;
2408
2409                       while (call != NULL)
2410                         {
2411                           struct call_info *call_next = call->next;
2412                           if (!insert_callee (sinfo->fun[i].start, call))
2413                             free (call);
2414                           call = call_next;
2415                         }
2416                       sinfo->fun[i].call_list = NULL;
2417                       sinfo->fun[i].non_root = TRUE;
2418                     }
2419                 }
2420             }
2421         }
2422     }
2423
2424   /* Find the call graph root(s).  */
2425   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2426     {
2427       extern const bfd_target bfd_elf32_spu_vec;
2428       asection *sec;
2429
2430       if (ibfd->xvec != &bfd_elf32_spu_vec)
2431         continue;
2432
2433       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
2434         {
2435           struct _spu_elf_section_data *sec_data;
2436           struct spu_elf_stack_info *sinfo;
2437
2438           if ((sec_data = spu_elf_section_data (sec)) != NULL
2439               && (sinfo = sec_data->stack_info) != NULL)
2440             {
2441               int i;
2442               for (i = 0; i < sinfo->num_fun; ++i)
2443                 if (!sinfo->fun[i].visit1)
2444                   mark_non_root (&sinfo->fun[i]);
2445             }
2446         }
2447     }
2448
2449   /* Remove cycles from the call graph.  We start from the root node(s)
2450      so that we break cycles in a reasonable place.  */
2451   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2452     {
2453       extern const bfd_target bfd_elf32_spu_vec;
2454       asection *sec;
2455
2456       if (ibfd->xvec != &bfd_elf32_spu_vec)
2457         continue;
2458
2459       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
2460         {
2461           struct _spu_elf_section_data *sec_data;
2462           struct spu_elf_stack_info *sinfo;
2463
2464           if ((sec_data = spu_elf_section_data (sec)) != NULL
2465               && (sinfo = sec_data->stack_info) != NULL)
2466             {
2467               int i;
2468               for (i = 0; i < sinfo->num_fun; ++i)
2469                 if (!sinfo->fun[i].non_root)
2470                   call_graph_traverse (&sinfo->fun[i], info);
2471             }
2472         }
2473     }
2474
2475   return TRUE;
2476 }
2477
2478 /* Descend the call graph for FUN, accumulating total stack required.  */
2479
2480 static bfd_vma
2481 sum_stack (struct function_info *fun,
2482            struct bfd_link_info *info,
2483            int emit_stack_syms)
2484 {
2485   struct call_info *call;
2486   struct function_info *max = NULL;
2487   bfd_vma max_stack = fun->stack;
2488   bfd_vma stack;
2489   const char *f1;
2490
2491   if (fun->visit3)
2492     return max_stack;
2493
2494   for (call = fun->call_list; call; call = call->next)
2495     {
2496       stack = sum_stack (call->fun, info, emit_stack_syms);
2497       /* Include caller stack for normal calls, don't do so for
2498          tail calls.  fun->stack here is local stack usage for
2499          this function.  */
2500       if (!call->is_tail)
2501         stack += fun->stack;
2502       if (max_stack < stack)
2503         {
2504           max_stack = stack;
2505           max = call->fun;
2506         }
2507     }
2508
2509   f1 = func_name (fun);
2510   info->callbacks->minfo (_("%s: 0x%v 0x%v\n"), f1, fun->stack, max_stack);
2511
2512   if (fun->call_list)
2513     {
2514       info->callbacks->minfo (_("  calls:\n"));
2515       for (call = fun->call_list; call; call = call->next)
2516         {
2517           const char *f2 = func_name (call->fun);
2518           const char *ann1 = call->fun == max ? "*" : " ";
2519           const char *ann2 = call->is_tail ? "t" : " ";
2520
2521           info->callbacks->minfo (_("   %s%s %s\n"), ann1, ann2, f2);
2522         }
2523     }
2524
2525   /* Now fun->stack holds cumulative stack.  */
2526   fun->stack = max_stack;
2527   fun->visit3 = TRUE;
2528
2529   if (emit_stack_syms)
2530     {
2531       struct spu_link_hash_table *htab = spu_hash_table (info);
2532       char *name = bfd_malloc (18 + strlen (f1));
2533       struct elf_link_hash_entry *h;
2534
2535       if (name != NULL)
2536         {
2537           if (fun->global || ELF_ST_BIND (fun->u.sym->st_info) == STB_GLOBAL)
2538             sprintf (name, "__stack_%s", f1);
2539           else
2540             sprintf (name, "__stack_%x_%s", fun->sec->id & 0xffffffff, f1);
2541
2542           h = elf_link_hash_lookup (&htab->elf, name, TRUE, TRUE, FALSE);
2543           free (name);
2544           if (h != NULL
2545               && (h->root.type == bfd_link_hash_new
2546                   || h->root.type == bfd_link_hash_undefined
2547                   || h->root.type == bfd_link_hash_undefweak))
2548             {
2549               h->root.type = bfd_link_hash_defined;
2550               h->root.u.def.section = bfd_abs_section_ptr;
2551               h->root.u.def.value = max_stack;
2552               h->size = 0;
2553               h->type = 0;
2554               h->ref_regular = 1;
2555               h->def_regular = 1;
2556               h->ref_regular_nonweak = 1;
2557               h->forced_local = 1;
2558               h->non_elf = 0;
2559             }
2560         }
2561     }
2562
2563   return max_stack;
2564 }
2565
2566 /* Provide an estimate of total stack required.  */
2567
2568 static bfd_boolean
2569 spu_elf_stack_analysis (bfd *output_bfd,
2570                         struct bfd_link_info *info,
2571                         int emit_stack_syms)
2572 {
2573   bfd *ibfd;
2574   bfd_vma max_stack = 0;
2575
2576   if (!discover_functions (output_bfd, info))
2577     return FALSE;
2578
2579   if (!build_call_tree (output_bfd, info))
2580     return FALSE;
2581
2582   info->callbacks->info (_("Stack size for call graph root nodes.\n"));
2583   info->callbacks->minfo (_("\nStack size for functions.  "
2584                             "Annotations: '*' max stack, 't' tail call\n"));
2585   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2586     {
2587       extern const bfd_target bfd_elf32_spu_vec;
2588       asection *sec;
2589
2590       if (ibfd->xvec != &bfd_elf32_spu_vec)
2591         continue;
2592
2593       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
2594         {
2595           struct _spu_elf_section_data *sec_data;
2596           struct spu_elf_stack_info *sinfo;
2597
2598           if ((sec_data = spu_elf_section_data (sec)) != NULL
2599               && (sinfo = sec_data->stack_info) != NULL)
2600             {
2601               int i;
2602               for (i = 0; i < sinfo->num_fun; ++i)
2603                 {
2604                   if (!sinfo->fun[i].non_root)
2605                     {
2606                       bfd_vma stack;
2607                       const char *f1;
2608
2609                       stack = sum_stack (&sinfo->fun[i], info,
2610                                          emit_stack_syms);
2611                       f1 = func_name (&sinfo->fun[i]);
2612                       info->callbacks->info (_("  %s: 0x%v\n"),
2613                                               f1, stack);
2614                       if (max_stack < stack)
2615                         max_stack = stack;
2616                     }
2617                 }
2618             }
2619         }
2620     }
2621
2622   info->callbacks->info (_("Maximum stack required is 0x%v\n"), max_stack);
2623   return TRUE;
2624 }
2625
2626 /* Perform a final link.  */
2627
2628 static bfd_boolean
2629 spu_elf_final_link (bfd *output_bfd, struct bfd_link_info *info)
2630 {
2631   struct spu_link_hash_table *htab = spu_hash_table (info);
2632
2633   if (htab->stack_analysis
2634       && !spu_elf_stack_analysis (output_bfd, info, htab->emit_stack_syms))
2635     info->callbacks->einfo ("%X%P: stack analysis error: %E\n");
2636
2637   return bfd_elf_final_link (output_bfd, info);
2638 }
2639
2640 /* Called when not normally emitting relocs, ie. !info->relocatable
2641    and !info->emitrelocations.  Returns a count of special relocs
2642    that need to be emitted.  */
2643
2644 static unsigned int
2645 spu_elf_count_relocs (asection *sec, Elf_Internal_Rela *relocs)
2646 {
2647   unsigned int count = 0;
2648   Elf_Internal_Rela *relend = relocs + sec->reloc_count;
2649
2650   for (; relocs < relend; relocs++)
2651     {
2652       int r_type = ELF32_R_TYPE (relocs->r_info);
2653       if (r_type == R_SPU_PPU32 || r_type == R_SPU_PPU64)
2654         ++count;
2655     }
2656
2657   return count;
2658 }
2659
2660 /* Apply RELOCS to CONTENTS of INPUT_SECTION from INPUT_BFD.  */
2661
2662 static bfd_boolean
2663 spu_elf_relocate_section (bfd *output_bfd,
2664                           struct bfd_link_info *info,
2665                           bfd *input_bfd,
2666                           asection *input_section,
2667                           bfd_byte *contents,
2668                           Elf_Internal_Rela *relocs,
2669                           Elf_Internal_Sym *local_syms,
2670                           asection **local_sections)
2671 {
2672   Elf_Internal_Shdr *symtab_hdr;
2673   struct elf_link_hash_entry **sym_hashes;
2674   Elf_Internal_Rela *rel, *relend;
2675   struct spu_link_hash_table *htab;
2676   bfd_boolean ret = TRUE;
2677   bfd_boolean emit_these_relocs = FALSE;
2678
2679   htab = spu_hash_table (info);
2680   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2681   sym_hashes = (struct elf_link_hash_entry **) (elf_sym_hashes (input_bfd));
2682
2683   rel = relocs;
2684   relend = relocs + input_section->reloc_count;
2685   for (; rel < relend; rel++)
2686     {
2687       int r_type;
2688       reloc_howto_type *howto;
2689       unsigned long r_symndx;
2690       Elf_Internal_Sym *sym;
2691       asection *sec;
2692       struct elf_link_hash_entry *h;
2693       const char *sym_name;
2694       bfd_vma relocation;
2695       bfd_vma addend;
2696       bfd_reloc_status_type r;
2697       bfd_boolean unresolved_reloc;
2698       bfd_boolean warned;
2699       bfd_boolean branch;
2700
2701       r_symndx = ELF32_R_SYM (rel->r_info);
2702       r_type = ELF32_R_TYPE (rel->r_info);
2703       if (r_type == R_SPU_PPU32 || r_type == R_SPU_PPU64)
2704         {
2705           emit_these_relocs = TRUE;
2706           continue;
2707         }
2708
2709       howto = elf_howto_table + r_type;
2710       unresolved_reloc = FALSE;
2711       warned = FALSE;
2712       h = NULL;
2713       sym = NULL;
2714       sec = NULL;
2715       if (r_symndx < symtab_hdr->sh_info)
2716         {
2717           sym = local_syms + r_symndx;
2718           sec = local_sections[r_symndx];
2719           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
2720           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2721         }
2722       else
2723         {
2724           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2725                                    r_symndx, symtab_hdr, sym_hashes,
2726                                    h, sec, relocation,
2727                                    unresolved_reloc, warned);
2728           sym_name = h->root.root.string;
2729         }
2730
2731       if (sec != NULL && elf_discarded_section (sec))
2732         {
2733           /* For relocs against symbols from removed linkonce sections,
2734              or sections discarded by a linker script, we just want the
2735              section contents zeroed.  Avoid any special processing.  */
2736           _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
2737           rel->r_info = 0;
2738           rel->r_addend = 0;
2739           continue;
2740         }
2741
2742       if (info->relocatable)
2743         continue;
2744
2745       if (unresolved_reloc)
2746         {
2747           (*_bfd_error_handler)
2748             (_("%B(%s+0x%lx): unresolvable %s relocation against symbol `%s'"),
2749              input_bfd,
2750              bfd_get_section_name (input_bfd, input_section),
2751              (long) rel->r_offset,
2752              howto->name,
2753              sym_name);
2754           ret = FALSE;
2755         }
2756
2757       /* If this symbol is in an overlay area, we may need to relocate
2758          to the overlay stub.  */
2759       addend = rel->r_addend;
2760       branch = (is_branch (contents + rel->r_offset)
2761                 || is_hint (contents + rel->r_offset));
2762       if (needs_ovl_stub (sym_name, sec, input_section, htab, branch))
2763         {
2764           char *stub_name;
2765           struct spu_stub_hash_entry *sh;
2766
2767           stub_name = spu_stub_name (sec, h, rel);
2768           if (stub_name == NULL)
2769             return FALSE;
2770
2771           sh = (struct spu_stub_hash_entry *)
2772             bfd_hash_lookup (&htab->stub_hash_table, stub_name, FALSE, FALSE);
2773           if (sh != NULL)
2774             {
2775               relocation = (htab->stub->output_section->vma
2776                             + htab->stub->output_offset
2777                             + sh->off);
2778               addend = 0;
2779             }
2780           free (stub_name);
2781         }
2782
2783       r = _bfd_final_link_relocate (howto,
2784                                     input_bfd,
2785                                     input_section,
2786                                     contents,
2787                                     rel->r_offset, relocation, addend);
2788
2789       if (r != bfd_reloc_ok)
2790         {
2791           const char *msg = (const char *) 0;
2792
2793           switch (r)
2794             {
2795             case bfd_reloc_overflow:
2796               if (!((*info->callbacks->reloc_overflow)
2797                     (info, (h ? &h->root : NULL), sym_name, howto->name,
2798                      (bfd_vma) 0, input_bfd, input_section, rel->r_offset)))
2799                 return FALSE;
2800               break;
2801
2802             case bfd_reloc_undefined:
2803               if (!((*info->callbacks->undefined_symbol)
2804                     (info, sym_name, input_bfd, input_section,
2805                      rel->r_offset, TRUE)))
2806                 return FALSE;
2807               break;
2808
2809             case bfd_reloc_outofrange:
2810               msg = _("internal error: out of range error");
2811               goto common_error;
2812
2813             case bfd_reloc_notsupported:
2814               msg = _("internal error: unsupported relocation error");
2815               goto common_error;
2816
2817             case bfd_reloc_dangerous:
2818               msg = _("internal error: dangerous error");
2819               goto common_error;
2820
2821             default:
2822               msg = _("internal error: unknown error");
2823               /* fall through */
2824
2825             common_error:
2826               if (!((*info->callbacks->warning)
2827                     (info, msg, sym_name, input_bfd, input_section,
2828                      rel->r_offset)))
2829                 return FALSE;
2830               break;
2831             }
2832         }
2833     }
2834
2835   if (ret
2836       && emit_these_relocs
2837       && !info->relocatable
2838       && !info->emitrelocations)
2839     {
2840       Elf_Internal_Rela *wrel;
2841       Elf_Internal_Shdr *rel_hdr;
2842
2843       wrel = rel = relocs;
2844       relend = relocs + input_section->reloc_count;
2845       for (; rel < relend; rel++)
2846         {
2847           int r_type;
2848
2849           r_type = ELF32_R_TYPE (rel->r_info);
2850           if (r_type == R_SPU_PPU32 || r_type == R_SPU_PPU64)
2851             *wrel++ = *rel;
2852         }
2853       input_section->reloc_count = wrel - relocs;
2854       /* Backflips for _bfd_elf_link_output_relocs.  */
2855       rel_hdr = &elf_section_data (input_section)->rel_hdr;
2856       rel_hdr->sh_size = input_section->reloc_count * rel_hdr->sh_entsize;
2857       ret = 2;
2858     }
2859
2860   return ret;
2861 }
2862
2863 /* Adjust _SPUEAR_ syms to point at their overlay stubs.  */
2864
2865 static bfd_boolean
2866 spu_elf_output_symbol_hook (struct bfd_link_info *info,
2867                             const char *sym_name ATTRIBUTE_UNUSED,
2868                             Elf_Internal_Sym *sym,
2869                             asection *sym_sec ATTRIBUTE_UNUSED,
2870                             struct elf_link_hash_entry *h)
2871 {
2872   struct spu_link_hash_table *htab = spu_hash_table (info);
2873
2874   if (!info->relocatable
2875       && htab->num_overlays != 0
2876       && h != NULL
2877       && (h->root.type == bfd_link_hash_defined
2878           || h->root.type == bfd_link_hash_defweak)
2879       && h->def_regular
2880       && strncmp (h->root.root.string, "_SPUEAR_", 8) == 0)
2881     {
2882       static Elf_Internal_Rela zero_rel;
2883       char *stub_name = spu_stub_name (h->root.u.def.section, h, &zero_rel);
2884       struct spu_stub_hash_entry *sh;
2885
2886       if (stub_name == NULL)
2887         return FALSE;
2888       sh = (struct spu_stub_hash_entry *)
2889         bfd_hash_lookup (&htab->stub_hash_table, stub_name, FALSE, FALSE);
2890       free (stub_name);
2891       if (sh == NULL)
2892         return TRUE;
2893       sym->st_shndx
2894         = _bfd_elf_section_from_bfd_section (htab->stub->output_section->owner,
2895                                              htab->stub->output_section);
2896       sym->st_value = (htab->stub->output_section->vma
2897                        + htab->stub->output_offset
2898                        + sh->off);
2899     }
2900
2901   return TRUE;
2902 }
2903
2904 static int spu_plugin = 0;
2905
2906 void
2907 spu_elf_plugin (int val)
2908 {
2909   spu_plugin = val;
2910 }
2911
2912 /* Set ELF header e_type for plugins.  */
2913
2914 static void
2915 spu_elf_post_process_headers (bfd *abfd,
2916                               struct bfd_link_info *info ATTRIBUTE_UNUSED)
2917 {
2918   if (spu_plugin)
2919     {
2920       Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
2921
2922       i_ehdrp->e_type = ET_DYN;
2923     }
2924 }
2925
2926 /* We may add an extra PT_LOAD segment for .toe.  We also need extra
2927    segments for overlays.  */
2928
2929 static int
2930 spu_elf_additional_program_headers (bfd *abfd, struct bfd_link_info *info)
2931 {
2932   struct spu_link_hash_table *htab = spu_hash_table (info);
2933   int extra = htab->num_overlays;
2934   asection *sec;
2935
2936   if (extra)
2937     ++extra;
2938
2939   sec = bfd_get_section_by_name (abfd, ".toe");
2940   if (sec != NULL && (sec->flags & SEC_LOAD) != 0)
2941     ++extra;
2942
2943   return extra;
2944 }
2945
2946 /* Remove .toe section from other PT_LOAD segments and put it in
2947    a segment of its own.  Put overlays in separate segments too.  */
2948
2949 static bfd_boolean
2950 spu_elf_modify_segment_map (bfd *abfd, struct bfd_link_info *info)
2951 {
2952   asection *toe, *s;
2953   struct elf_segment_map *m;
2954   unsigned int i;
2955
2956   if (info == NULL)
2957     return TRUE;
2958
2959   toe = bfd_get_section_by_name (abfd, ".toe");
2960   for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
2961     if (m->p_type == PT_LOAD && m->count > 1)
2962       for (i = 0; i < m->count; i++)
2963         if ((s = m->sections[i]) == toe
2964             || spu_elf_section_data (s)->ovl_index != 0)
2965           {
2966             struct elf_segment_map *m2;
2967             bfd_vma amt;
2968
2969             if (i + 1 < m->count)
2970               {
2971                 amt = sizeof (struct elf_segment_map);
2972                 amt += (m->count - (i + 2)) * sizeof (m->sections[0]);
2973                 m2 = bfd_zalloc (abfd, amt);
2974                 if (m2 == NULL)
2975                   return FALSE;
2976                 m2->count = m->count - (i + 1);
2977                 memcpy (m2->sections, m->sections + i + 1,
2978                         m2->count * sizeof (m->sections[0]));
2979                 m2->p_type = PT_LOAD;
2980                 m2->next = m->next;
2981                 m->next = m2;
2982               }
2983             m->count = 1;
2984             if (i != 0)
2985               {
2986                 m->count = i;
2987                 amt = sizeof (struct elf_segment_map);
2988                 m2 = bfd_zalloc (abfd, amt);
2989                 if (m2 == NULL)
2990                   return FALSE;
2991                 m2->p_type = PT_LOAD;
2992                 m2->count = 1;
2993                 m2->sections[0] = s;
2994                 m2->next = m->next;
2995                 m->next = m2;
2996               }
2997             break;
2998           }
2999
3000   return TRUE;
3001 }
3002
3003 /* Check that all loadable section VMAs lie in the range
3004    LO .. HI inclusive.  */
3005
3006 asection *
3007 spu_elf_check_vma (bfd *abfd, bfd_vma lo, bfd_vma hi)
3008 {
3009   struct elf_segment_map *m;
3010   unsigned int i;
3011
3012   for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
3013     if (m->p_type == PT_LOAD)
3014       for (i = 0; i < m->count; i++)
3015         if (m->sections[i]->size != 0
3016             && (m->sections[i]->vma < lo
3017                 || m->sections[i]->vma > hi
3018                 || m->sections[i]->vma + m->sections[i]->size - 1 > hi))
3019           return m->sections[i];
3020
3021   return NULL;
3022 }
3023
3024 /* Tweak phdrs before writing them out.  */
3025
3026 static int
3027 spu_elf_modify_program_headers (bfd *abfd, struct bfd_link_info *info)
3028 {
3029   const struct elf_backend_data *bed;
3030   struct elf_obj_tdata *tdata;
3031   Elf_Internal_Phdr *phdr, *last;
3032   struct spu_link_hash_table *htab;
3033   unsigned int count;
3034   unsigned int i;
3035
3036   if (info == NULL)
3037     return TRUE;
3038
3039   bed = get_elf_backend_data (abfd);
3040   tdata = elf_tdata (abfd);
3041   phdr = tdata->phdr;
3042   count = tdata->program_header_size / bed->s->sizeof_phdr;
3043   htab = spu_hash_table (info);
3044   if (htab->num_overlays != 0)
3045     {
3046       struct elf_segment_map *m;
3047       unsigned int o;
3048
3049       for (i = 0, m = elf_tdata (abfd)->segment_map; m; ++i, m = m->next)
3050         if (m->count != 0
3051             && (o = spu_elf_section_data (m->sections[0])->ovl_index) != 0)
3052           {
3053             /* Mark this as an overlay header.  */
3054             phdr[i].p_flags |= PF_OVERLAY;
3055
3056             if (htab->ovtab != NULL && htab->ovtab->size != 0)
3057               {
3058                 bfd_byte *p = htab->ovtab->contents;
3059                 unsigned int off = (o - 1) * 16 + 8;
3060
3061                 /* Write file_off into _ovly_table.  */
3062                 bfd_put_32 (htab->ovtab->owner, phdr[i].p_offset, p + off);
3063               }
3064           }
3065     }
3066
3067   /* Round up p_filesz and p_memsz of PT_LOAD segments to multiples
3068      of 16.  This should always be possible when using the standard
3069      linker scripts, but don't create overlapping segments if
3070      someone is playing games with linker scripts.  */
3071   last = NULL;
3072   for (i = count; i-- != 0; )
3073     if (phdr[i].p_type == PT_LOAD)
3074       {
3075         unsigned adjust;
3076
3077         adjust = -phdr[i].p_filesz & 15;
3078         if (adjust != 0
3079             && last != NULL
3080             && phdr[i].p_offset + phdr[i].p_filesz > last->p_offset - adjust)
3081           break;
3082
3083         adjust = -phdr[i].p_memsz & 15;
3084         if (adjust != 0
3085             && last != NULL
3086             && phdr[i].p_filesz != 0
3087             && phdr[i].p_vaddr + phdr[i].p_memsz > last->p_vaddr - adjust
3088             && phdr[i].p_vaddr + phdr[i].p_memsz <= last->p_vaddr)
3089           break;
3090
3091         if (phdr[i].p_filesz != 0)
3092           last = &phdr[i];
3093       }
3094
3095   if (i == (unsigned int) -1)
3096     for (i = count; i-- != 0; )
3097       if (phdr[i].p_type == PT_LOAD)
3098         {
3099         unsigned adjust;
3100
3101         adjust = -phdr[i].p_filesz & 15;
3102         phdr[i].p_filesz += adjust;
3103
3104         adjust = -phdr[i].p_memsz & 15;
3105         phdr[i].p_memsz += adjust;
3106       }
3107
3108   return TRUE;
3109 }
3110
3111 #define TARGET_BIG_SYM          bfd_elf32_spu_vec
3112 #define TARGET_BIG_NAME         "elf32-spu"
3113 #define ELF_ARCH                bfd_arch_spu
3114 #define ELF_MACHINE_CODE        EM_SPU
3115 /* This matches the alignment need for DMA.  */
3116 #define ELF_MAXPAGESIZE         0x80
3117 #define elf_backend_rela_normal         1
3118 #define elf_backend_can_gc_sections     1
3119
3120 #define bfd_elf32_bfd_reloc_type_lookup         spu_elf_reloc_type_lookup
3121 #define bfd_elf32_bfd_reloc_name_lookup spu_elf_reloc_name_lookup
3122 #define elf_info_to_howto                       spu_elf_info_to_howto
3123 #define elf_backend_count_relocs                spu_elf_count_relocs
3124 #define elf_backend_relocate_section            spu_elf_relocate_section
3125 #define elf_backend_symbol_processing           spu_elf_backend_symbol_processing
3126 #define elf_backend_link_output_symbol_hook     spu_elf_output_symbol_hook
3127 #define bfd_elf32_new_section_hook              spu_elf_new_section_hook
3128 #define bfd_elf32_bfd_link_hash_table_create    spu_elf_link_hash_table_create
3129 #define bfd_elf32_bfd_link_hash_table_free      spu_elf_link_hash_table_free
3130
3131 #define elf_backend_additional_program_headers  spu_elf_additional_program_headers
3132 #define elf_backend_modify_segment_map          spu_elf_modify_segment_map
3133 #define elf_backend_modify_program_headers      spu_elf_modify_program_headers
3134 #define elf_backend_post_process_headers        spu_elf_post_process_headers
3135 #define elf_backend_special_sections            spu_elf_special_sections
3136 #define bfd_elf32_bfd_final_link                spu_elf_final_link
3137
3138 #include "elf32-target.h"