bfd/elf32-spu.c

   1 /* SPU specific support for 32-bit ELF
   2
   3    Copyright 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
   4
   5    This file is part of BFD, the Binary File Descriptor library.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License 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 "libiberty.h"
  23 #include "bfd.h"
  24 #include "bfdlink.h"
  25 #include "libbfd.h"
  26 #include "elf-bfd.h"
  27 #include "elf/spu.h"
  28 #include "elf32-spu.h"
  29
  30 /* We use RELA style relocs.  Don't define USE_REL.  */
  31
  32 static bfd_reloc_status_type spu_elf_rel9 (bfd *, arelent *, asymbol *,
  33                                            void *, asection *,
  34                                            bfd *, char **);
  35
  36 /* Values of type 'enum elf_spu_reloc_type' are used to index this
  37    array, so it must be declared in the order of that type.  */
  38
  39 static reloc_howto_type elf_howto_table[] = {
  40   HOWTO (R_SPU_NONE,       0, 0,  0, FALSE,  0, complain_overflow_dont,
  41          bfd_elf_generic_reloc, "SPU_NONE",
  42          FALSE, 0, 0x00000000, FALSE),
  43   HOWTO (R_SPU_ADDR10,     4, 2, 10, FALSE, 14, complain_overflow_bitfield,
  44          bfd_elf_generic_reloc, "SPU_ADDR10",
  45          FALSE, 0, 0x00ffc000, FALSE),
  46   HOWTO (R_SPU_ADDR16,     2, 2, 16, FALSE,  7, complain_overflow_bitfield,
  47          bfd_elf_generic_reloc, "SPU_ADDR16",
  48          FALSE, 0, 0x007fff80, FALSE),
  49   HOWTO (R_SPU_ADDR16_HI, 16, 2, 16, FALSE,  7, complain_overflow_bitfield,
  50          bfd_elf_generic_reloc, "SPU_ADDR16_HI",
  51          FALSE, 0, 0x007fff80, FALSE),
  52   HOWTO (R_SPU_ADDR16_LO,  0, 2, 16, FALSE,  7, complain_overflow_dont,
  53          bfd_elf_generic_reloc, "SPU_ADDR16_LO",
  54          FALSE, 0, 0x007fff80, FALSE),
  55   HOWTO (R_SPU_ADDR18,     0, 2, 18, FALSE,  7, complain_overflow_bitfield,
  56          bfd_elf_generic_reloc, "SPU_ADDR18",
  57          FALSE, 0, 0x01ffff80, FALSE),
  58   HOWTO (R_SPU_ADDR32,     0, 2, 32, FALSE,  0, complain_overflow_dont,
  59          bfd_elf_generic_reloc, "SPU_ADDR32",
  60          FALSE, 0, 0xffffffff, FALSE),
  61   HOWTO (R_SPU_REL16,      2, 2, 16,  TRUE,  7, complain_overflow_bitfield,
  62          bfd_elf_generic_reloc, "SPU_REL16",
  63          FALSE, 0, 0x007fff80, TRUE),
  64   HOWTO (R_SPU_ADDR7,      0, 2,  7, FALSE, 14, complain_overflow_dont,
  65          bfd_elf_generic_reloc, "SPU_ADDR7",
  66          FALSE, 0, 0x001fc000, FALSE),
  67   HOWTO (R_SPU_REL9,       2, 2,  9,  TRUE,  0, complain_overflow_signed,
  68          spu_elf_rel9,          "SPU_REL9",
  69          FALSE, 0, 0x0180007f, TRUE),
  70   HOWTO (R_SPU_REL9I,      2, 2,  9,  TRUE,  0, complain_overflow_signed,
  71          spu_elf_rel9,          "SPU_REL9I",
  72          FALSE, 0, 0x0000c07f, TRUE),
  73   HOWTO (R_SPU_ADDR10I,    0, 2, 10, FALSE, 14, complain_overflow_signed,
  74          bfd_elf_generic_reloc, "SPU_ADDR10I",
  75          FALSE, 0, 0x00ffc000, FALSE),
  76   HOWTO (R_SPU_ADDR16I,    0, 2, 16, FALSE,  7, complain_overflow_signed,
  77          bfd_elf_generic_reloc, "SPU_ADDR16I",
  78          FALSE, 0, 0x007fff80, FALSE),
  79   HOWTO (R_SPU_REL32,      0, 2, 32, TRUE,  0, complain_overflow_dont,
  80          bfd_elf_generic_reloc, "SPU_REL32",
  81          FALSE, 0, 0xffffffff, TRUE),
  82   HOWTO (R_SPU_ADDR16X,    0, 2, 16, FALSE,  7, complain_overflow_bitfield,
  83          bfd_elf_generic_reloc, "SPU_ADDR16X",
  84          FALSE, 0, 0x007fff80, FALSE),
  85   HOWTO (R_SPU_PPU32,      0, 2, 32, FALSE,  0, complain_overflow_dont,
  86          bfd_elf_generic_reloc, "SPU_PPU32",
  87          FALSE, 0, 0xffffffff, FALSE),
  88   HOWTO (R_SPU_PPU64,      0, 4, 64, FALSE,  0, complain_overflow_dont,
  89          bfd_elf_generic_reloc, "SPU_PPU64",
  90          FALSE, 0, -1, FALSE),
  91 };
  92
  93 static struct bfd_elf_special_section const spu_elf_special_sections[] = {
  94   { "._ea", 4, 0, SHT_PROGBITS, SHF_WRITE },
  95   { ".toe", 4, 0, SHT_NOBITS, SHF_ALLOC },
  96   { NULL, 0, 0, 0, 0 }
  97 };
  98
  99 static enum elf_spu_reloc_type
 100 spu_elf_bfd_to_reloc_type (bfd_reloc_code_real_type code)
 101 {
 102   switch (code)
 103     {
 104     default:
 105       return R_SPU_NONE;
 106     case BFD_RELOC_SPU_IMM10W:
 107       return R_SPU_ADDR10;
 108     case BFD_RELOC_SPU_IMM16W:
 109       return R_SPU_ADDR16;
 110     case BFD_RELOC_SPU_LO16:
 111       return R_SPU_ADDR16_LO;
 112     case BFD_RELOC_SPU_HI16:
 113       return R_SPU_ADDR16_HI;
 114     case BFD_RELOC_SPU_IMM18:
 115       return R_SPU_ADDR18;
 116     case BFD_RELOC_SPU_PCREL16:
 117       return R_SPU_REL16;
 118     case BFD_RELOC_SPU_IMM7:
 119       return R_SPU_ADDR7;
 120     case BFD_RELOC_SPU_IMM8:
 121       return R_SPU_NONE;
 122     case BFD_RELOC_SPU_PCREL9a:
 123       return R_SPU_REL9;
 124     case BFD_RELOC_SPU_PCREL9b:
 125       return R_SPU_REL9I;
 126     case BFD_RELOC_SPU_IMM10:
 127       return R_SPU_ADDR10I;
 128     case BFD_RELOC_SPU_IMM16:
 129       return R_SPU_ADDR16I;
 130     case BFD_RELOC_32:
 131       return R_SPU_ADDR32;
 132     case BFD_RELOC_32_PCREL:
 133       return R_SPU_REL32;
 134     case BFD_RELOC_SPU_PPU32:
 135       return R_SPU_PPU32;
 136     case BFD_RELOC_SPU_PPU64:
 137       return R_SPU_PPU64;
 138     }
 139 }
 140
 141 static void
 142 spu_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
 143                        arelent *cache_ptr,
 144                        Elf_Internal_Rela *dst)
 145 {
 146   enum elf_spu_reloc_type r_type;
 147
 148   r_type = (enum elf_spu_reloc_type) ELF32_R_TYPE (dst->r_info);
 149   BFD_ASSERT (r_type < R_SPU_max);
 150   cache_ptr->howto = &elf_howto_table[(int) r_type];
 151 }
 152
 153 static reloc_howto_type *
 154 spu_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 155                            bfd_reloc_code_real_type code)
 156 {
 157   enum elf_spu_reloc_type r_type = spu_elf_bfd_to_reloc_type (code);
 158
 159   if (r_type == R_SPU_NONE)
 160     return NULL;
 161
 162   return elf_howto_table + r_type;
 163 }
 164
 165 static reloc_howto_type *
 166 spu_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 167                            const char *r_name)
 168 {
 169   unsigned int i;
 170
 171   for (i = 0; i < sizeof (elf_howto_table) / sizeof (elf_howto_table[0]); i++)
 172     if (elf_howto_table[i].name != NULL
 173         && strcasecmp (elf_howto_table[i].name, r_name) == 0)
 174       return &elf_howto_table[i];
 175
 176   return NULL;
 177 }
 178
 179 /* Apply R_SPU_REL9 and R_SPU_REL9I relocs.  */
 180
 181 static bfd_reloc_status_type
 182 spu_elf_rel9 (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
 183               void *data, asection *input_section,
 184               bfd *output_bfd, char **error_message)
 185 {
 186   bfd_size_type octets;
 187   bfd_vma val;
 188   long insn;
 189
 190   /* If this is a relocatable link (output_bfd test tells us), just
 191      call the generic function.  Any adjustment will be done at final
 192      link time.  */
 193   if (output_bfd != NULL)
 194     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
 195                                   input_section, output_bfd, error_message);
 196
 197   if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
 198     return bfd_reloc_outofrange;
 199   octets = reloc_entry->address * bfd_octets_per_byte (abfd);
 200
 201   /* Get symbol value.  */
 202   val = 0;
 203   if (!bfd_is_com_section (symbol->section))
 204     val = symbol->value;
 205   if (symbol->section->output_section)
 206     val += symbol->section->output_section->vma;
 207
 208   val += reloc_entry->addend;
 209
 210   /* Make it pc-relative.  */
 211   val -= input_section->output_section->vma + input_section->output_offset;
 212
 213   val >>= 2;
 214   if (val + 256 >= 512)
 215     return bfd_reloc_overflow;
 216
 217   insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
 218
 219   /* Move two high bits of value to REL9I and REL9 position.
 220      The mask will take care of selecting the right field.  */
 221   val = (val & 0x7f) | ((val & 0x180) << 7) | ((val & 0x180) << 16);
 222   insn &= ~reloc_entry->howto->dst_mask;
 223   insn |= val & reloc_entry->howto->dst_mask;
 224   bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
 225   return bfd_reloc_ok;
 226 }
 227
 228 static bfd_boolean
 229 spu_elf_new_section_hook (bfd *abfd, asection *sec)
 230 {
 231   if (!sec->used_by_bfd)
 232     {
 233       struct _spu_elf_section_data *sdata;
 234
 235       sdata = bfd_zalloc (abfd, sizeof (*sdata));
 236       if (sdata == NULL)
 237         return FALSE;
 238       sec->used_by_bfd = sdata;
 239     }
 240
 241   return _bfd_elf_new_section_hook (abfd, sec);
 242 }
 243
 244 /* Set up overlay info for executables.  */
 245
 246 static bfd_boolean
 247 spu_elf_object_p (bfd *abfd)
 248 {
 249   if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
 250     {
 251       unsigned int i, num_ovl, num_buf;
 252       Elf_Internal_Phdr *phdr = elf_tdata (abfd)->phdr;
 253       Elf_Internal_Ehdr *ehdr = elf_elfheader (abfd);
 254       Elf_Internal_Phdr *last_phdr = NULL;
 255
 256       for (num_buf = 0, num_ovl = 0, i = 0; i < ehdr->e_phnum; i++, phdr++)
 257         if (phdr->p_type == PT_LOAD && (phdr->p_flags & PF_OVERLAY) != 0)
 258           {
 259             unsigned int j;
 260
 261             ++num_ovl;
 262             if (last_phdr == NULL
 263                 || ((last_phdr->p_vaddr ^ phdr->p_vaddr) & 0x3ffff) != 0)
 264               ++num_buf;
 265             last_phdr = phdr;
 266             for (j = 1; j < elf_numsections (abfd); j++)
 267               {
 268                 Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[j];
 269
 270                 if (ELF_IS_SECTION_IN_SEGMENT_MEMORY (shdr, phdr))
 271                   {
 272                     asection *sec = shdr->bfd_section;
 273                     spu_elf_section_data (sec)->u.o.ovl_index = num_ovl;
 274                     spu_elf_section_data (sec)->u.o.ovl_buf = num_buf;
 275                   }
 276               }
 277           }
 278     }
 279   return TRUE;
 280 }
 281
 282 /* Specially mark defined symbols named _EAR_* with BSF_KEEP so that
 283    strip --strip-unneeded will not remove them.  */
 284
 285 static void
 286 spu_elf_backend_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED, asymbol *sym)
 287 {
 288   if (sym->name != NULL
 289       && sym->section != bfd_abs_section_ptr
 290       && strncmp (sym->name, "_EAR_", 5) == 0)
 291     sym->flags |= BSF_KEEP;
 292 }
 293
 294 /* SPU ELF linker hash table.  */
 295
 296 struct spu_link_hash_table
 297 {
 298   struct elf_link_hash_table elf;
 299
 300   struct spu_elf_params *params;
 301
 302   /* Shortcuts to overlay sections.  */
 303   asection *ovtab;
 304   asection *init;
 305   asection *toe;
 306   asection **ovl_sec;
 307
 308   /* Count of stubs in each overlay section.  */
 309   unsigned int *stub_count;
 310
 311   /* The stub section for each overlay section.  */
 312   asection **stub_sec;
 313
 314   struct elf_link_hash_entry *ovly_entry[2];
 315
 316   /* Number of overlay buffers.  */
 317   unsigned int num_buf;
 318
 319   /* Total number of overlays.  */
 320   unsigned int num_overlays;
 321
 322   /* For soft icache.  */
 323   unsigned int line_size_log2;
 324   unsigned int num_lines_log2;
 325   unsigned int fromelem_size_log2;
 326
 327   /* How much memory we have.  */
 328   unsigned int local_store;
 329   /* Local store --auto-overlay should reserve for non-overlay
 330      functions and data.  */
 331   unsigned int overlay_fixed;
 332   /* Local store --auto-overlay should reserve for stack and heap.  */
 333   unsigned int reserved;
 334   /* If reserved is not specified, stack analysis will calculate a value
 335      for the stack.  This parameter adjusts that value to allow for
 336      negative sp access (the ABI says 2000 bytes below sp are valid,
 337      and the overlay manager uses some of this area).  */
 338   int extra_stack_space;
 339   /* Count of overlay stubs needed in non-overlay area.  */
 340   unsigned int non_ovly_stub;
 341
 342   /* Set on error.  */
 343   unsigned int stub_err : 1;
 344 };
 345
 346 /* Hijack the generic got fields for overlay stub accounting.  */
 347
 348 struct got_entry
 349 {
 350   struct got_entry *next;
 351   unsigned int ovl;
 352   union {
 353     bfd_vma addend;
 354     bfd_vma br_addr;
 355   };
 356   bfd_vma stub_addr;
 357 };
 358
 359 #define spu_hash_table(p) \
 360   ((struct spu_link_hash_table *) ((p)->hash))
 361
 362 struct call_info
 363 {
 364   struct function_info *fun;
 365   struct call_info *next;
 366   unsigned int count;
 367   unsigned int max_depth;
 368   unsigned int is_tail : 1;
 369   unsigned int is_pasted : 1;
 370   unsigned int priority : 13;
 371 };
 372
 373 struct function_info
 374 {
 375   /* List of functions called.  Also branches to hot/cold part of
 376      function.  */
 377   struct call_info *call_list;
 378   /* For hot/cold part of function, point to owner.  */
 379   struct function_info *start;
 380   /* Symbol at start of function.  */
 381   union {
 382     Elf_Internal_Sym *sym;
 383     struct elf_link_hash_entry *h;
 384   } u;
 385   /* Function section.  */
 386   asection *sec;
 387   asection *rodata;
 388   /* Where last called from, and number of sections called from.  */
 389   asection *last_caller;
 390   unsigned int call_count;
 391   /* Address range of (this part of) function.  */
 392   bfd_vma lo, hi;
 393   /* Offset where we found a store of lr, or -1 if none found.  */
 394   bfd_vma lr_store;
 395   /* Offset where we found the stack adjustment insn.  */
 396   bfd_vma sp_adjust;
 397   /* Stack usage.  */
 398   int stack;
 399   /* Distance from root of call tree.  Tail and hot/cold branches
 400      count as one deeper.  We aren't counting stack frames here.  */
 401   unsigned int depth;
 402   /* Set if global symbol.  */
 403   unsigned int global : 1;
 404   /* Set if known to be start of function (as distinct from a hunk
 405      in hot/cold section.  */
 406   unsigned int is_func : 1;
 407   /* Set if not a root node.  */
 408   unsigned int non_root : 1;
 409   /* Flags used during call tree traversal.  It's cheaper to replicate
 410      the visit flags than have one which needs clearing after a traversal.  */
 411   unsigned int visit1 : 1;
 412   unsigned int visit2 : 1;
 413   unsigned int marking : 1;
 414   unsigned int visit3 : 1;
 415   unsigned int visit4 : 1;
 416   unsigned int visit5 : 1;
 417   unsigned int visit6 : 1;
 418   unsigned int visit7 : 1;
 419 };
 420
 421 struct spu_elf_stack_info
 422 {
 423   int num_fun;
 424   int max_fun;
 425   /* Variable size array describing functions, one per contiguous
 426      address range belonging to a function.  */
 427   struct function_info fun[1];
 428 };
 429
 430 static struct function_info *find_function (asection *, bfd_vma,
 431                                             struct bfd_link_info *);
 432
 433 /* Create a spu ELF linker hash table.  */
 434
 435 static struct bfd_link_hash_table *
 436 spu_elf_link_hash_table_create (bfd *abfd)
 437 {
 438   struct spu_link_hash_table *htab;
 439
 440   htab = bfd_malloc (sizeof (*htab));
 441   if (htab == NULL)
 442     return NULL;
 443
 444   if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd,
 445                                       _bfd_elf_link_hash_newfunc,
 446                                       sizeof (struct elf_link_hash_entry)))
 447     {
 448       free (htab);
 449       return NULL;
 450     }
 451
 452   memset (&htab->ovtab, 0,
 453           sizeof (*htab) - offsetof (struct spu_link_hash_table, ovtab));
 454
 455   htab->elf.init_got_refcount.refcount = 0;
 456   htab->elf.init_got_refcount.glist = NULL;
 457   htab->elf.init_got_offset.offset = 0;
 458   htab->elf.init_got_offset.glist = NULL;
 459   return &htab->elf.root;
 460 }
 461
 462 void
 463 spu_elf_setup (struct bfd_link_info *info, struct spu_elf_params *params)
 464 {
 465   bfd_vma max_branch_log2;
 466
 467   struct spu_link_hash_table *htab = spu_hash_table (info);
 468   htab->params = params;
 469   htab->line_size_log2 = bfd_log2 (htab->params->line_size);
 470   htab->num_lines_log2 = bfd_log2 (htab->params->num_lines);
 471
 472   /* For the software i-cache, we provide a "from" list whose size
 473      is a power-of-two number of quadwords, big enough to hold one
 474      byte per outgoing branch.  Compute this number here.  */
 475   max_branch_log2 = bfd_log2 (htab->params->max_branch);
 476   htab->fromelem_size_log2 = max_branch_log2 > 4 ? max_branch_log2 - 4 : 0;
 477 }
 478
 479 /* Find the symbol for the given R_SYMNDX in IBFD and set *HP and *SYMP
 480    to (hash, NULL) for global symbols, and (NULL, sym) for locals.  Set
 481    *SYMSECP to the symbol's section.  *LOCSYMSP caches local syms.  */
 482
 483 static bfd_boolean
 484 get_sym_h (struct elf_link_hash_entry **hp,
 485            Elf_Internal_Sym **symp,
 486            asection **symsecp,
 487            Elf_Internal_Sym **locsymsp,
 488            unsigned long r_symndx,
 489            bfd *ibfd)
 490 {
 491   Elf_Internal_Shdr *symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
 492
 493   if (r_symndx >= symtab_hdr->sh_info)
 494     {
 495       struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
 496       struct elf_link_hash_entry *h;
 497
 498       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 499       while (h->root.type == bfd_link_hash_indirect
 500              || h->root.type == bfd_link_hash_warning)
 501         h = (struct elf_link_hash_entry *) h->root.u.i.link;
 502
 503       if (hp != NULL)
 504         *hp = h;
 505
 506       if (symp != NULL)
 507         *symp = NULL;
 508
 509       if (symsecp != NULL)
 510         {
 511           asection *symsec = NULL;
 512           if (h->root.type == bfd_link_hash_defined
 513               || h->root.type == bfd_link_hash_defweak)
 514             symsec = h->root.u.def.section;
 515           *symsecp = symsec;
 516         }
 517     }
 518   else
 519     {
 520       Elf_Internal_Sym *sym;
 521       Elf_Internal_Sym *locsyms = *locsymsp;
 522
 523       if (locsyms == NULL)
 524         {
 525           locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
 526           if (locsyms == NULL)
 527             locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
 528                                             symtab_hdr->sh_info,
 529                                             0, NULL, NULL, NULL);
 530           if (locsyms == NULL)
 531             return FALSE;
 532           *locsymsp = locsyms;
 533         }
 534       sym = locsyms + r_symndx;
 535
 536       if (hp != NULL)
 537         *hp = NULL;
 538
 539       if (symp != NULL)
 540         *symp = sym;
 541
 542       if (symsecp != NULL)
 543         *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
 544     }
 545
 546   return TRUE;
 547 }
 548
 549 /* Create the note section if not already present.  This is done early so
 550    that the linker maps the sections to the right place in the output.  */
 551
 552 bfd_boolean
 553 spu_elf_create_sections (struct bfd_link_info *info)
 554 {
 555   bfd *ibfd;
 556
 557   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
 558     if (bfd_get_section_by_name (ibfd, SPU_PTNOTE_SPUNAME) != NULL)
 559       break;
 560
 561   if (ibfd == NULL)
 562     {
 563       /* Make SPU_PTNOTE_SPUNAME section.  */
 564       asection *s;
 565       size_t name_len;
 566       size_t size;
 567       bfd_byte *data;
 568       flagword flags;
 569
 570       ibfd = info->input_bfds;
 571       flags = SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
 572       s = bfd_make_section_anyway_with_flags (ibfd, SPU_PTNOTE_SPUNAME, flags);
 573       if (s == NULL
 574           || !bfd_set_section_alignment (ibfd, s, 4))
 575         return FALSE;
 576
 577       name_len = strlen (bfd_get_filename (info->output_bfd)) + 1;
 578       size = 12 + ((sizeof (SPU_PLUGIN_NAME) + 3) & -4);
 579       size += (name_len + 3) & -4;
 580
 581       if (!bfd_set_section_size (ibfd, s, size))
 582         return FALSE;
 583
 584       data = bfd_zalloc (ibfd, size);
 585       if (data == NULL)
 586         return FALSE;
 587
 588       bfd_put_32 (ibfd, sizeof (SPU_PLUGIN_NAME), data + 0);
 589       bfd_put_32 (ibfd, name_len, data + 4);
 590       bfd_put_32 (ibfd, 1, data + 8);
 591       memcpy (data + 12, SPU_PLUGIN_NAME, sizeof (SPU_PLUGIN_NAME));
 592       memcpy (data + 12 + ((sizeof (SPU_PLUGIN_NAME) + 3) & -4),
 593               bfd_get_filename (info->output_bfd), name_len);
 594       s->contents = data;
 595     }
 596
 597   return TRUE;
 598 }
 599
 600 /* qsort predicate to sort sections by vma.  */
 601
 602 static int
 603 sort_sections (const void *a, const void *b)
 604 {
 605   const asection *const *s1 = a;
 606   const asection *const *s2 = b;
 607   bfd_signed_vma delta = (*s1)->vma - (*s2)->vma;
 608
 609   if (delta != 0)
 610     return delta < 0 ? -1 : 1;
 611
 612   return (*s1)->index - (*s2)->index;
 613 }
 614
 615 /* Identify overlays in the output bfd, and number them.
 616    Returns 0 on error, 1 if no overlays, 2 if overlays.  */
 617
 618 int
 619 spu_elf_find_overlays (struct bfd_link_info *info)
 620 {
 621   struct spu_link_hash_table *htab = spu_hash_table (info);
 622   asection **alloc_sec;
 623   unsigned int i, n, ovl_index, num_buf;
 624   asection *s;
 625   bfd_vma ovl_end;
 626   static const char *const entry_names[2][2] = {
 627     { "__ovly_load", "__icache_br_handler" },
 628     { "__ovly_return", "__icache_call_handler" }
 629   };
 630
 631   if (info->output_bfd->section_count < 2)
 632     return 1;
 633
 634   alloc_sec
 635     = bfd_malloc (info->output_bfd->section_count * sizeof (*alloc_sec));
 636   if (alloc_sec == NULL)
 637     return 0;
 638
 639   /* Pick out all the alloced sections.  */
 640   for (n = 0, s = info->output_bfd->sections; s != NULL; s = s->next)
 641     if ((s->flags & SEC_ALLOC) != 0
 642         && (s->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) != SEC_THREAD_LOCAL
 643         && s->size != 0)
 644       alloc_sec[n++] = s;
 645
 646   if (n == 0)
 647     {
 648       free (alloc_sec);
 649       return 1;
 650     }
 651
 652   /* Sort them by vma.  */
 653   qsort (alloc_sec, n, sizeof (*alloc_sec), sort_sections);
 654
 655   ovl_end = alloc_sec[0]->vma + alloc_sec[0]->size;
 656   if (htab->params->ovly_flavour == ovly_soft_icache)
 657     {
 658       /* Look for an overlapping vma to find the first overlay section.  */
 659       bfd_vma vma_start = 0;
 660       bfd_vma lma_start = 0;
 661
 662       for (i = 1; i < n; i++)
 663         {
 664           s = alloc_sec[i];
 665           if (s->vma < ovl_end)
 666             {
 667               asection *s0 = alloc_sec[i - 1];
 668               vma_start = s0->vma;
 669               if (strncmp (s0->name, ".ovl.init", 9) != 0)
 670                 lma_start = s0->lma;
 671               else
 672                 lma_start = s->lma;
 673               ovl_end = (s0->vma
 674                          + ((bfd_vma) 1
 675                             << (htab->num_lines_log2 + htab->line_size_log2)));
 676               --i;
 677               break;
 678             }
 679           else
 680             ovl_end = s->vma + s->size;
 681         }
 682
 683       /* Now find any sections within the cache area.  */
 684       for (ovl_index = 0, num_buf = 0; i < n; i++)
 685         {
 686           s = alloc_sec[i];
 687           if (s->vma >= ovl_end)
 688             break;
 689
 690           /* A section in an overlay area called .ovl.init is not
 691              an overlay, in the sense that it might be loaded in
 692              by the overlay manager, but rather the initial
 693              section contents for the overlay buffer.  */
 694           if (strncmp (s->name, ".ovl.init", 9) != 0)
 695             {
 696               num_buf = ((s->vma - vma_start) >> htab->line_size_log2) + 1;
 697               if (((s->vma - vma_start) & (htab->params->line_size - 1))
 698                   || ((s->lma - lma_start) & (htab->params->line_size - 1)))
 699                 {
 700                   info->callbacks->einfo (_("%X%P: overlay section %A "
 701                                             "does not start on a cache line.\n"),
 702                                           s);
 703                   bfd_set_error (bfd_error_bad_value);
 704                   return 0;
 705                 }
 706               else if (s->size > htab->params->line_size)
 707                 {
 708                   info->callbacks->einfo (_("%X%P: overlay section %A "
 709                                             "is larger than a cache line.\n"),
 710                                           s);
 711                   bfd_set_error (bfd_error_bad_value);
 712                   return 0;
 713                 }
 714
 715               alloc_sec[ovl_index++] = s;
 716               spu_elf_section_data (s)->u.o.ovl_index
 717                 = ((s->lma - lma_start) >>  htab->line_size_log2) + 1;
 718               spu_elf_section_data (s)->u.o.ovl_buf = num_buf;
 719             }
 720         }
 721
 722       /* Ensure there are no more overlay sections.  */
 723       for ( ; i < n; i++)
 724         {
 725           s = alloc_sec[i];
 726           if (s->vma < ovl_end)
 727             {
 728               info->callbacks->einfo (_("%X%P: overlay section %A "
 729                                         "is not in cache area.\n"),
 730                                       alloc_sec[i-1]);
 731               bfd_set_error (bfd_error_bad_value);
 732               return 0;
 733             }
 734           else
 735             ovl_end = s->vma + s->size;
 736         }
 737     }
 738   else
 739     {
 740       /* Look for overlapping vmas.  Any with overlap must be overlays.
 741          Count them.  Also count the number of overlay regions.  */
 742       for (ovl_index = 0, num_buf = 0, i = 1; i < n; i++)
 743         {
 744           s = alloc_sec[i];
 745           if (s->vma < ovl_end)
 746             {
 747               asection *s0 = alloc_sec[i - 1];
 748
 749               if (spu_elf_section_data (s0)->u.o.ovl_index == 0)
 750                 {
 751                   ++num_buf;
 752                   if (strncmp (s0->name, ".ovl.init", 9) != 0)
 753                     {
 754                       alloc_sec[ovl_index] = s0;
 755                       spu_elf_section_data (s0)->u.o.ovl_index = ++ovl_index;
 756                       spu_elf_section_data (s0)->u.o.ovl_buf = num_buf;
 757                     }
 758                   else
 759                     ovl_end = s->vma + s->size;
 760                 }
 761               if (strncmp (s->name, ".ovl.init", 9) != 0)
 762                 {
 763                   alloc_sec[ovl_index] = s;
 764                   spu_elf_section_data (s)->u.o.ovl_index = ++ovl_index;
 765                   spu_elf_section_data (s)->u.o.ovl_buf = num_buf;
 766                   if (s0->vma != s->vma)
 767                     {
 768                       info->callbacks->einfo (_("%X%P: overlay sections %A "
 769                                                 "and %A do not start at the "
 770                                                 "same address.\n"),
 771                                               s0, s);
 772                       bfd_set_error (bfd_error_bad_value);
 773                       return 0;
 774                     }
 775                   if (ovl_end < s->vma + s->size)
 776                     ovl_end = s->vma + s->size;
 777                 }
 778             }
 779           else
 780             ovl_end = s->vma + s->size;
 781         }
 782     }
 783
 784   htab->num_overlays = ovl_index;
 785   htab->num_buf = num_buf;
 786   htab->ovl_sec = alloc_sec;
 787
 788   if (ovl_index == 0)
 789     return 1;
 790
 791   for (i = 0; i < 2; i++)
 792     {
 793       const char *name;
 794       struct elf_link_hash_entry *h;
 795
 796       name = entry_names[i][htab->params->ovly_flavour];
 797       h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
 798       if (h == NULL)
 799         return 0;
 800
 801       if (h->root.type == bfd_link_hash_new)
 802         {
 803           h->root.type = bfd_link_hash_undefined;
 804           h->ref_regular = 1;
 805           h->ref_regular_nonweak = 1;
 806           h->non_elf = 0;
 807         }
 808       htab->ovly_entry[i] = h;
 809     }
 810
 811   return 2;
 812 }
 813
 814 /* Non-zero to use bra in overlay stubs rather than br.  */
 815 #define BRA_STUBS 0
 816
 817 #define BRA     0x30000000
 818 #define BRASL   0x31000000
 819 #define BR      0x32000000
 820 #define BRSL    0x33000000
 821 #define NOP     0x40200000
 822 #define LNOP    0x00200000
 823 #define ILA     0x42000000
 824
 825 /* Return true for all relative and absolute branch instructions.
 826    bra   00110000 0..
 827    brasl 00110001 0..
 828    br    00110010 0..
 829    brsl  00110011 0..
 830    brz   00100000 0..
 831    brnz  00100001 0..
 832    brhz  00100010 0..
 833    brhnz 00100011 0..  */
 834
 835 static bfd_boolean
 836 is_branch (const unsigned char *insn)
 837 {
 838   return (insn[0] & 0xec) == 0x20 && (insn[1] & 0x80) == 0;
 839 }
 840
 841 /* Return true for all indirect branch instructions.
 842    bi     00110101 000
 843    bisl   00110101 001
 844    iret   00110101 010
 845    bisled 00110101 011
 846    biz    00100101 000
 847    binz   00100101 001
 848    bihz   00100101 010
 849    bihnz  00100101 011  */
 850
 851 static bfd_boolean
 852 is_indirect_branch (const unsigned char *insn)
 853 {
 854   return (insn[0] & 0xef) == 0x25 && (insn[1] & 0x80) == 0;
 855 }
 856
 857 /* Return true for branch hint instructions.
 858    hbra  0001000..
 859    hbrr  0001001..  */
 860
 861 static bfd_boolean
 862 is_hint (const unsigned char *insn)
 863 {
 864   return (insn[0] & 0xfc) == 0x10;
 865 }
 866
 867 /* True if INPUT_SECTION might need overlay stubs.  */
 868
 869 static bfd_boolean
 870 maybe_needs_stubs (asection *input_section)
 871 {
 872   /* No stubs for debug sections and suchlike.  */
 873   if ((input_section->flags & SEC_ALLOC) == 0)
 874     return FALSE;
 875
 876   /* No stubs for link-once sections that will be discarded.  */
 877   if (input_section->output_section == bfd_abs_section_ptr)
 878     return FALSE;
 879
 880   /* Don't create stubs for .eh_frame references.  */
 881   if (strcmp (input_section->name, ".eh_frame") == 0)
 882     return FALSE;
 883
 884   return TRUE;
 885 }
 886
 887 enum _stub_type
 888 {
 889   no_stub,
 890   call_ovl_stub,
 891   br000_ovl_stub,
 892   br001_ovl_stub,
 893   br010_ovl_stub,
 894   br011_ovl_stub,
 895   br100_ovl_stub,
 896   br101_ovl_stub,
 897   br110_ovl_stub,
 898   br111_ovl_stub,
 899   nonovl_stub,
 900   stub_error
 901 };
 902
 903 /* Return non-zero if this reloc symbol should go via an overlay stub.
 904    Return 2 if the stub must be in non-overlay area.  */
 905
 906 static enum _stub_type
 907 needs_ovl_stub (struct elf_link_hash_entry *h,
 908                 Elf_Internal_Sym *sym,
 909                 asection *sym_sec,
 910                 asection *input_section,
 911                 Elf_Internal_Rela *irela,
 912                 bfd_byte *contents,
 913                 struct bfd_link_info *info)
 914 {
 915   struct spu_link_hash_table *htab = spu_hash_table (info);
 916   enum elf_spu_reloc_type r_type;
 917   unsigned int sym_type;
 918   bfd_boolean branch, hint, call;
 919   enum _stub_type ret = no_stub;
 920   bfd_byte insn[4];
 921
 922   if (sym_sec == NULL
 923       || sym_sec->output_section == bfd_abs_section_ptr
 924       || spu_elf_section_data (sym_sec->output_section) == NULL)
 925     return ret;
 926
 927   if (h != NULL)
 928     {
 929       /* Ensure no stubs for user supplied overlay manager syms.  */
 930       if (h == htab->ovly_entry[0] || h == htab->ovly_entry[1])
 931         return ret;
 932
 933       /* setjmp always goes via an overlay stub, because then the return
 934          and hence the longjmp goes via __ovly_return.  That magically
 935          makes setjmp/longjmp between overlays work.  */
 936       if (strncmp (h->root.root.string, "setjmp", 6) == 0
 937           && (h->root.root.string[6] == '\0' || h->root.root.string[6] == '@'))
 938         ret = call_ovl_stub;
 939     }
 940
 941   if (h != NULL)
 942     sym_type = h->type;
 943   else
 944     sym_type = ELF_ST_TYPE (sym->st_info);
 945
 946   r_type = ELF32_R_TYPE (irela->r_info);
 947   branch = FALSE;
 948   hint = FALSE;
 949   call = FALSE;
 950   if (r_type == R_SPU_REL16 || r_type == R_SPU_ADDR16)
 951     {
 952       if (contents == NULL)
 953         {
 954           contents = insn;
 955           if (!bfd_get_section_contents (input_section->owner,
 956                                          input_section,
 957                                          contents,
 958                                          irela->r_offset, 4))
 959             return stub_error;
 960         }
 961       else
 962         contents += irela->r_offset;
 963
 964       branch = is_branch (contents);
 965       hint = is_hint (contents);
 966       if (branch || hint)
 967         {
 968           call = (contents[0] & 0xfd) == 0x31;
 969           if (call
 970               && sym_type != STT_FUNC
 971               && contents != insn)
 972             {
 973               /* It's common for people to write assembly and forget
 974                  to give function symbols the right type.  Handle
 975                  calls to such symbols, but warn so that (hopefully)
 976                  people will fix their code.  We need the symbol
 977                  type to be correct to distinguish function pointer
 978                  initialisation from other pointer initialisations.  */
 979               const char *sym_name;
 980
 981               if (h != NULL)
 982                 sym_name = h->root.root.string;
 983               else
 984                 {
 985                   Elf_Internal_Shdr *symtab_hdr;
 986                   symtab_hdr = &elf_tdata (input_section->owner)->symtab_hdr;
 987                   sym_name = bfd_elf_sym_name (input_section->owner,
 988                                                symtab_hdr,
 989                                                sym,
 990                                                sym_sec);
 991                 }
 992               (*_bfd_error_handler) (_("warning: call to non-function"
 993                                        " symbol %s defined in %B"),
 994                                      sym_sec->owner, sym_name);
 995
 996             }
 997         }
 998     }
 999
1000   if ((!branch && htab->params->ovly_flavour == ovly_soft_icache)
1001       || (sym_type != STT_FUNC
1002           && !(branch || hint)
1003           && (sym_sec->flags & SEC_CODE) == 0))
1004     return no_stub;
1005
1006   /* Usually, symbols in non-overlay sections don't need stubs.  */
1007   if (spu_elf_section_data (sym_sec->output_section)->u.o.ovl_index == 0
1008       && !htab->params->non_overlay_stubs)
1009     return ret;
1010
1011   /* A reference from some other section to a symbol in an overlay
1012      section needs a stub.  */
1013   if (spu_elf_section_data (sym_sec->output_section)->u.o.ovl_index
1014        != spu_elf_section_data (input_section->output_section)->u.o.ovl_index)
1015     {
1016       if (call || sym_type == STT_FUNC)
1017         ret = call_ovl_stub;
1018       else
1019         {
1020           ret = br000_ovl_stub;
1021
1022           if (branch)
1023             {
1024               unsigned int lrlive = (contents[1] & 0x70) >> 4;
1025               ret += lrlive;
1026             }
1027         }
1028     }
1029
1030   /* If this insn isn't a branch then we are possibly taking the
1031      address of a function and passing it out somehow.  Soft-icache code
1032      always generates inline code to do indirect branches.  */
1033   if (!(branch || hint)
1034       && sym_type == STT_FUNC
1035       && htab->params->ovly_flavour != ovly_soft_icache)
1036     ret = nonovl_stub;
1037
1038   return ret;
1039 }
1040
1041 static bfd_boolean
1042 count_stub (struct spu_link_hash_table *htab,
1043             bfd *ibfd,
1044             asection *isec,
1045             enum _stub_type stub_type,
1046             struct elf_link_hash_entry *h,
1047             const Elf_Internal_Rela *irela)
1048 {
1049   unsigned int ovl = 0;
1050   struct got_entry *g, **head;
1051   bfd_vma addend;
1052
1053   /* If this instruction is a branch or call, we need a stub
1054      for it.  One stub per function per overlay.
1055      If it isn't a branch, then we are taking the address of
1056      this function so need a stub in the non-overlay area
1057      for it.  One stub per function.  */
1058   if (stub_type != nonovl_stub)
1059     ovl = spu_elf_section_data (isec->output_section)->u.o.ovl_index;
1060
1061   if (h != NULL)
1062     head = &h->got.glist;
1063   else
1064     {
1065       if (elf_local_got_ents (ibfd) == NULL)
1066         {
1067           bfd_size_type amt = (elf_tdata (ibfd)->symtab_hdr.sh_info
1068                                * sizeof (*elf_local_got_ents (ibfd)));
1069           elf_local_got_ents (ibfd) = bfd_zmalloc (amt);
1070           if (elf_local_got_ents (ibfd) == NULL)
1071             return FALSE;
1072         }
1073       head = elf_local_got_ents (ibfd) + ELF32_R_SYM (irela->r_info);
1074     }
1075
1076   if (htab->params->ovly_flavour == ovly_soft_icache)
1077     {
1078       htab->stub_count[ovl] += 1;
1079       return TRUE;
1080     }
1081
1082   addend = 0;
1083   if (irela != NULL)
1084     addend = irela->r_addend;
1085
1086   if (ovl == 0)
1087     {
1088       struct got_entry *gnext;
1089
1090       for (g = *head; g != NULL; g = g->next)
1091         if (g->addend == addend && g->ovl == 0)
1092           break;
1093
1094       if (g == NULL)
1095         {
1096           /* Need a new non-overlay area stub.  Zap other stubs.  */
1097           for (g = *head; g != NULL; g = gnext)
1098             {
1099               gnext = g->next;
1100               if (g->addend == addend)
1101                 {
1102                   htab->stub_count[g->ovl] -= 1;
1103                   free (g);
1104                 }
1105             }
1106         }
1107     }
1108   else
1109     {
1110       for (g = *head; g != NULL; g = g->next)
1111         if (g->addend == addend && (g->ovl == ovl || g->ovl == 0))
1112           break;
1113     }
1114
1115   if (g == NULL)
1116     {
1117       g = bfd_malloc (sizeof *g);
1118       if (g == NULL)
1119         return FALSE;
1120       g->ovl = ovl;
1121       g->addend = addend;
1122       g->stub_addr = (bfd_vma) -1;
1123       g->next = *head;
1124       *head = g;
1125
1126       htab->stub_count[ovl] += 1;
1127     }
1128
1129   return TRUE;
1130 }
1131
1132 /* Support two sizes of overlay stubs, a slower more compact stub of two
1133    intructions, and a faster stub of four instructions.
1134    Soft-icache stubs are four or eight words.  */
1135
1136 static unsigned int
1137 ovl_stub_size (struct spu_elf_params *params)
1138 {
1139   return 16 << params->ovly_flavour >> params->compact_stub;
1140 }
1141
1142 static unsigned int
1143 ovl_stub_size_log2 (struct spu_elf_params *params)
1144 {
1145   return 4 + params->ovly_flavour - params->compact_stub;
1146 }
1147
1148 /* Two instruction overlay stubs look like:
1149
1150    brsl $75,__ovly_load
1151    .word target_ovl_and_address
1152
1153    ovl_and_address is a word with the overlay number in the top 14 bits
1154    and local store address in the bottom 18 bits.
1155
1156    Four instruction overlay stubs look like:
1157
1158    ila $78,ovl_number
1159    lnop
1160    ila $79,target_address
1161    br __ovly_load
1162
1163    Software icache stubs are:
1164
1165    .word target_index
1166    .word target_ia;
1167    .word lrlive_branchlocalstoreaddr;
1168    brasl $75,__icache_br_handler
1169    .quad xor_pattern
1170 */
1171
1172 static bfd_boolean
1173 build_stub (struct bfd_link_info *info,
1174             bfd *ibfd,
1175             asection *isec,
1176             enum _stub_type stub_type,
1177             struct elf_link_hash_entry *h,
1178             const Elf_Internal_Rela *irela,
1179             bfd_vma dest,
1180             asection *dest_sec)
1181 {
1182   struct spu_link_hash_table *htab = spu_hash_table (info);
1183   unsigned int ovl, dest_ovl, set_id;
1184   struct got_entry *g, **head;
1185   asection *sec;
1186   bfd_vma addend, from, to, br_dest, patt;
1187   unsigned int lrlive;
1188
1189   ovl = 0;
1190   if (stub_type != nonovl_stub)
1191     ovl = spu_elf_section_data (isec->output_section)->u.o.ovl_index;
1192
1193   if (h != NULL)
1194     head = &h->got.glist;
1195   else
1196     head = elf_local_got_ents (ibfd) + ELF32_R_SYM (irela->r_info);
1197
1198   addend = 0;
1199   if (irela != NULL)
1200     addend = irela->r_addend;
1201
1202   if (htab->params->ovly_flavour == ovly_soft_icache)
1203     {
1204       g = bfd_malloc (sizeof *g);
1205       if (g == NULL)
1206         return FALSE;
1207       g->ovl = ovl;
1208       g->br_addr = 0;
1209       if (irela != NULL)
1210         g->br_addr = (irela->r_offset
1211                       + isec->output_offset
1212                       + isec->output_section->vma);
1213       g->next = *head;
1214       *head = g;
1215     }
1216   else
1217     {
1218       for (g = *head; g != NULL; g = g->next)
1219         if (g->addend == addend && (g->ovl == ovl || g->ovl == 0))
1220           break;
1221       if (g == NULL)
1222         abort ();
1223
1224       if (g->ovl == 0 && ovl != 0)
1225         return TRUE;
1226
1227       if (g->stub_addr != (bfd_vma) -1)
1228         return TRUE;
1229     }
1230
1231   sec = htab->stub_sec[ovl];
1232   dest += dest_sec->output_offset + dest_sec->output_section->vma;
1233   from = sec->size + sec->output_offset + sec->output_section->vma;
1234   g->stub_addr = from;
1235   to = (htab->ovly_entry[0]->root.u.def.value
1236         + htab->ovly_entry[0]->root.u.def.section->output_offset
1237         + htab->ovly_entry[0]->root.u.def.section->output_section->vma);
1238
1239   if (((dest | to | from) & 3) != 0)
1240     {
1241       htab->stub_err = 1;
1242       return FALSE;
1243     }
1244   dest_ovl = spu_elf_section_data (dest_sec->output_section)->u.o.ovl_index;
1245
1246   if (htab->params->ovly_flavour == ovly_normal
1247       && !htab->params->compact_stub)
1248     {
1249       bfd_put_32 (sec->owner, ILA + ((dest_ovl << 7) & 0x01ffff80) + 78,
1250                   sec->contents + sec->size);
1251       bfd_put_32 (sec->owner, LNOP,
1252                   sec->contents + sec->size + 4);
1253       bfd_put_32 (sec->owner, ILA + ((dest << 7) & 0x01ffff80) + 79,
1254                   sec->contents + sec->size + 8);
1255       if (!BRA_STUBS)
1256         bfd_put_32 (sec->owner, BR + (((to - (from + 12)) << 5) & 0x007fff80),
1257                     sec->contents + sec->size + 12);
1258       else
1259         bfd_put_32 (sec->owner, BRA + ((to << 5) & 0x007fff80),
1260                     sec->contents + sec->size + 12);
1261     }
1262   else if (htab->params->ovly_flavour == ovly_normal
1263            && htab->params->compact_stub)
1264     {
1265       if (!BRA_STUBS)
1266         bfd_put_32 (sec->owner, BRSL + (((to - from) << 5) & 0x007fff80) + 75,
1267                     sec->contents + sec->size);
1268       else
1269         bfd_put_32 (sec->owner, BRASL + ((to << 5) & 0x007fff80) + 75,
1270                     sec->contents + sec->size);
1271       bfd_put_32 (sec->owner, (dest & 0x3ffff) | (dest_ovl << 18),
1272                   sec->contents + sec->size + 4);
1273     }
1274   else if (htab->params->ovly_flavour == ovly_soft_icache
1275            && htab->params->compact_stub)
1276     {
1277       lrlive = 0;
1278       if (stub_type == nonovl_stub)
1279         ;
1280       else if (stub_type == call_ovl_stub)
1281         /* A brsl makes lr live and *(*sp+16) is live.
1282            Tail calls have the same liveness.  */
1283         lrlive = 5;
1284       else if (!htab->params->lrlive_analysis)
1285         /* Assume stack frame and lr save.  */
1286         lrlive = 1;
1287       else if (irela != NULL)
1288         {
1289           /* Analyse branch instructions.  */
1290           struct function_info *caller;
1291           bfd_vma off;
1292
1293           caller = find_function (isec, irela->r_offset, info);
1294           if (caller->start == NULL)
1295             off = irela->r_offset;
1296           else
1297             {
1298               struct function_info *found = NULL;
1299
1300               /* Find the earliest piece of this function that
1301                  has frame adjusting instructions.  We might
1302                  see dynamic frame adjustment (eg. for alloca)
1303                  in some later piece, but functions using
1304                  alloca always set up a frame earlier.  Frame
1305                  setup instructions are always in one piece.  */
1306               if (caller->lr_store != (bfd_vma) -1
1307                   || caller->sp_adjust != (bfd_vma) -1)
1308                 found = caller;
1309               while (caller->start != NULL)
1310                 {
1311                   caller = caller->start;
1312                   if (caller->lr_store != (bfd_vma) -1
1313                       || caller->sp_adjust != (bfd_vma) -1)
1314                     found = caller;
1315                 }
1316               if (found != NULL)
1317                 caller = found;
1318               off = (bfd_vma) -1;
1319             }
1320
1321           if (off > caller->sp_adjust)
1322             {
1323               if (off > caller->lr_store)
1324                 /* Only *(*sp+16) is live.  */
1325                 lrlive = 1;
1326               else
1327                 /* If no lr save, then we must be in a
1328                    leaf function with a frame.
1329                    lr is still live.  */
1330                 lrlive = 4;
1331             }
1332           else if (off > caller->lr_store)
1333             {
1334               /* Between lr save and stack adjust.  */
1335               lrlive = 3;
1336               /* This should never happen since prologues won't
1337                  be split here.  */
1338               BFD_ASSERT (0);
1339             }
1340           else
1341             /* On entry to function.  */
1342             lrlive = 5;
1343
1344           if (stub_type != br000_ovl_stub
1345               && lrlive != stub_type - br000_ovl_stub)
1346             info->callbacks->einfo (_("%A:0x%v lrlive .brinfo (%u) differs "
1347                                       "from analysis (%u)\n"),
1348                                     isec, irela->r_offset, lrlive,
1349                                     stub_type - br000_ovl_stub);
1350         }
1351
1352       /* If given lrlive info via .brinfo, use it.  */
1353       if (stub_type > br000_ovl_stub)
1354         lrlive = stub_type - br000_ovl_stub;
1355
1356       if (ovl == 0)
1357         to = (htab->ovly_entry[1]->root.u.def.value
1358               + htab->ovly_entry[1]->root.u.def.section->output_offset
1359               + htab->ovly_entry[1]->root.u.def.section->output_section->vma);
1360
1361       /* The branch that uses this stub goes to stub_addr + 4.  We'll
1362          set up an xor pattern that can be used by the icache manager
1363          to modify this branch to go directly to its destination.  */
1364       g->stub_addr += 4;
1365       br_dest = g->stub_addr;
1366       if (irela == NULL)
1367         {
1368           /* Except in the case of _SPUEAR_ stubs, the branch in
1369              question is the one in the stub itself.  */
1370           BFD_ASSERT (stub_type == nonovl_stub);
1371           g->br_addr = g->stub_addr;
1372           br_dest = to;
1373         }
1374
1375       set_id = ((dest_ovl - 1) >> htab->num_lines_log2) + 1;
1376       bfd_put_32 (sec->owner, (set_id << 18) | (dest & 0x3ffff),
1377                   sec->contents + sec->size);
1378       bfd_put_32 (sec->owner, BRASL + ((to << 5) & 0x007fff80) + 75,
1379                   sec->contents + sec->size + 4);
1380       bfd_put_32 (sec->owner, (lrlive << 29) | (g->br_addr & 0x3ffff),
1381                   sec->contents + sec->size + 8);
1382       patt = dest ^ br_dest;
1383       if (irela != NULL && ELF32_R_TYPE (irela->r_info) == R_SPU_REL16)
1384         patt = (dest - g->br_addr) ^ (br_dest - g->br_addr);
1385       bfd_put_32 (sec->owner, (patt << 5) & 0x007fff80,
1386                   sec->contents + sec->size + 12);
1387
1388       if (ovl == 0)
1389         /* Extra space for linked list entries.  */
1390         sec->size += 16;
1391     }
1392   else
1393     abort ();
1394
1395   sec->size += ovl_stub_size (htab->params);
1396
1397   if (htab->params->emit_stub_syms)
1398     {
1399       size_t len;
1400       char *name;
1401       int add;
1402
1403       len = 8 + sizeof (".ovl_call.") - 1;
1404       if (h != NULL)
1405         len += strlen (h->root.root.string);
1406       else
1407         len += 8 + 1 + 8;
1408       add = 0;
1409       if (irela != NULL)
1410         add = (int) irela->r_addend & 0xffffffff;
1411       if (add != 0)
1412         len += 1 + 8;
1413       name = bfd_malloc (len);
1414       if (name == NULL)
1415         return FALSE;
1416
1417       sprintf (name, "%08x.ovl_call.", g->ovl);
1418       if (h != NULL)
1419         strcpy (name + 8 + sizeof (".ovl_call.") - 1, h->root.root.string);
1420       else
1421         sprintf (name + 8 + sizeof (".ovl_call.") - 1, "%x:%x",
1422                  dest_sec->id & 0xffffffff,
1423                  (int) ELF32_R_SYM (irela->r_info) & 0xffffffff);
1424       if (add != 0)
1425         sprintf (name + len - 9, "+%x", add);
1426
1427       h = elf_link_hash_lookup (&htab->elf, name, TRUE, TRUE, FALSE);
1428       free (name);
1429       if (h == NULL)
1430         return FALSE;
1431       if (h->root.type == bfd_link_hash_new)
1432         {
1433           h->root.type = bfd_link_hash_defined;
1434           h->root.u.def.section = sec;
1435           h->size = ovl_stub_size (htab->params);
1436           h->root.u.def.value = sec->size - h->size;
1437           h->type = STT_FUNC;
1438           h->ref_regular = 1;
1439           h->def_regular = 1;
1440           h->ref_regular_nonweak = 1;
1441           h->forced_local = 1;
1442           h->non_elf = 0;
1443         }
1444     }
1445
1446   return TRUE;
1447 }
1448
1449 /* Called via elf_link_hash_traverse to allocate stubs for any _SPUEAR_
1450    symbols.  */
1451
1452 static bfd_boolean
1453 allocate_spuear_stubs (struct elf_link_hash_entry *h, void *inf)
1454 {
1455   /* Symbols starting with _SPUEAR_ need a stub because they may be
1456      invoked by the PPU.  */
1457   struct bfd_link_info *info = inf;
1458   struct spu_link_hash_table *htab = spu_hash_table (info);
1459   asection *sym_sec;
1460
1461   if ((h->root.type == bfd_link_hash_defined
1462        || h->root.type == bfd_link_hash_defweak)
1463       && h->def_regular
1464       && strncmp (h->root.root.string, "_SPUEAR_", 8) == 0
1465       && (sym_sec = h->root.u.def.section) != NULL
1466       && sym_sec->output_section != bfd_abs_section_ptr
1467       && spu_elf_section_data (sym_sec->output_section) != NULL
1468       && (spu_elf_section_data (sym_sec->output_section)->u.o.ovl_index != 0
1469           || htab->params->non_overlay_stubs))
1470     {
1471       return count_stub (htab, NULL, NULL, nonovl_stub, h, NULL);
1472     }
1473
1474   return TRUE;
1475 }
1476
1477 static bfd_boolean
1478 build_spuear_stubs (struct elf_link_hash_entry *h, void *inf)
1479 {
1480   /* Symbols starting with _SPUEAR_ need a stub because they may be
1481      invoked by the PPU.  */
1482   struct bfd_link_info *info = inf;
1483   struct spu_link_hash_table *htab = spu_hash_table (info);
1484   asection *sym_sec;
1485
1486   if ((h->root.type == bfd_link_hash_defined
1487        || h->root.type == bfd_link_hash_defweak)
1488       && h->def_regular
1489       && strncmp (h->root.root.string, "_SPUEAR_", 8) == 0
1490       && (sym_sec = h->root.u.def.section) != NULL
1491       && sym_sec->output_section != bfd_abs_section_ptr
1492       && spu_elf_section_data (sym_sec->output_section) != NULL
1493       && (spu_elf_section_data (sym_sec->output_section)->u.o.ovl_index != 0
1494           || htab->params->non_overlay_stubs))
1495     {
1496       return build_stub (info, NULL, NULL, nonovl_stub, h, NULL,
1497                          h->root.u.def.value, sym_sec);
1498     }
1499
1500   return TRUE;
1501 }
1502
1503 /* Size or build stubs.  */
1504
1505 static bfd_boolean
1506 process_stubs (struct bfd_link_info *info, bfd_boolean build)
1507 {
1508   struct spu_link_hash_table *htab = spu_hash_table (info);
1509   bfd *ibfd;
1510
1511   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
1512     {
1513       extern const bfd_target bfd_elf32_spu_vec;
1514       Elf_Internal_Shdr *symtab_hdr;
1515       asection *isec;
1516       Elf_Internal_Sym *local_syms = NULL;
1517
1518       if (ibfd->xvec != &bfd_elf32_spu_vec)
1519         continue;
1520
1521       /* We'll need the symbol table in a second.  */
1522       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
1523       if (symtab_hdr->sh_info == 0)
1524         continue;
1525
1526       /* Walk over each section attached to the input bfd.  */
1527       for (isec = ibfd->sections; isec != NULL; isec = isec->next)
1528         {
1529           Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
1530
1531           /* If there aren't any relocs, then there's nothing more to do.  */
1532           if ((isec->flags & SEC_RELOC) == 0
1533               || isec->reloc_count == 0)
1534             continue;
1535
1536           if (!maybe_needs_stubs (isec))
1537             continue;
1538
1539           /* Get the relocs.  */
1540           internal_relocs = _bfd_elf_link_read_relocs (ibfd, isec, NULL, NULL,
1541                                                        info->keep_memory);
1542           if (internal_relocs == NULL)
1543             goto error_ret_free_local;
1544
1545           /* Now examine each relocation.  */
1546           irela = internal_relocs;
1547           irelaend = irela + isec->reloc_count;
1548           for (; irela < irelaend; irela++)
1549             {
1550               enum elf_spu_reloc_type r_type;
1551               unsigned int r_indx;
1552               asection *sym_sec;
1553               Elf_Internal_Sym *sym;
1554               struct elf_link_hash_entry *h;
1555               enum _stub_type stub_type;
1556
1557               r_type = ELF32_R_TYPE (irela->r_info);
1558               r_indx = ELF32_R_SYM (irela->r_info);
1559
1560               if (r_type >= R_SPU_max)
1561                 {
1562                   bfd_set_error (bfd_error_bad_value);
1563                 error_ret_free_internal:
1564                   if (elf_section_data (isec)->relocs != internal_relocs)
1565                     free (internal_relocs);
1566                 error_ret_free_local:
1567                   if (local_syms != NULL
1568                       && (symtab_hdr->contents
1569                           != (unsigned char *) local_syms))
1570                     free (local_syms);
1571                   return FALSE;
1572                 }
1573
1574               /* Determine the reloc target section.  */
1575               if (!get_sym_h (&h, &sym, &sym_sec, &local_syms, r_indx, ibfd))
1576                 goto error_ret_free_internal;
1577
1578               stub_type = needs_ovl_stub (h, sym, sym_sec, isec, irela,
1579                                           NULL, info);
1580               if (stub_type == no_stub)
1581                 continue;
1582               else if (stub_type == stub_error)
1583                 goto error_ret_free_internal;
1584
1585               if (htab->stub_count == NULL)
1586                 {
1587                   bfd_size_type amt;
1588                   amt = (htab->num_overlays + 1) * sizeof (*htab->stub_count);
1589                   htab->stub_count = bfd_zmalloc (amt);
1590                   if (htab->stub_count == NULL)
1591                     goto error_ret_free_internal;
1592                 }
1593
1594               if (!build)
1595                 {
1596                   if (!count_stub (htab, ibfd, isec, stub_type, h, irela))
1597                     goto error_ret_free_internal;
1598                 }
1599               else
1600                 {
1601                   bfd_vma dest;
1602
1603                   if (h != NULL)
1604                     dest = h->root.u.def.value;
1605                   else
1606                     dest = sym->st_value;
1607                   dest += irela->r_addend;
1608                   if (!build_stub (info, ibfd, isec, stub_type, h, irela,
1609                                    dest, sym_sec))
1610                     goto error_ret_free_internal;
1611                 }
1612             }
1613
1614           /* We're done with the internal relocs, free them.  */
1615           if (elf_section_data (isec)->relocs != internal_relocs)
1616             free (internal_relocs);
1617         }
1618
1619       if (local_syms != NULL
1620           && symtab_hdr->contents != (unsigned char *) local_syms)
1621         {
1622           if (!info->keep_memory)
1623             free (local_syms);
1624           else
1625             symtab_hdr->contents = (unsigned char *) local_syms;
1626         }
1627     }
1628
1629   return TRUE;
1630 }
1631
1632 /* Allocate space for overlay call and return stubs.
1633    Return 0 on error, 1 if no stubs, 2 otherwise.  */
1634
1635 int
1636 spu_elf_size_stubs (struct bfd_link_info *info)
1637 {
1638   struct spu_link_hash_table *htab;
1639   bfd *ibfd;
1640   bfd_size_type amt;
1641   flagword flags;
1642   unsigned int i;
1643   asection *stub;
1644
1645   if (!process_stubs (info, FALSE))
1646     return 0;
1647
1648   htab = spu_hash_table (info);
1649   elf_link_hash_traverse (&htab->elf, allocate_spuear_stubs, info);
1650   if (htab->stub_err)
1651     return 0;
1652
1653   if (htab->stub_count == NULL)
1654     return 1;
1655
1656   ibfd = info->input_bfds;
1657   amt = (htab->num_overlays + 1) * sizeof (*htab->stub_sec);
1658   htab->stub_sec = bfd_zmalloc (amt);
1659   if (htab->stub_sec == NULL)
1660     return 0;
1661
1662   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
1663            | SEC_HAS_CONTENTS | SEC_IN_MEMORY);
1664   stub = bfd_make_section_anyway_with_flags (ibfd, ".stub", flags);
1665   htab->stub_sec[0] = stub;
1666   if (stub == NULL
1667       || !bfd_set_section_alignment (ibfd, stub,
1668                                      ovl_stub_size_log2 (htab->params)))
1669     return 0;
1670   stub->size = htab->stub_count[0] * ovl_stub_size (htab->params);
1671   if (htab->params->ovly_flavour == ovly_soft_icache)
1672     /* Extra space for linked list entries.  */
1673     stub->size += htab->stub_count[0] * 16;
1674
1675   for (i = 0; i < htab->num_overlays; ++i)
1676     {
1677       asection *osec = htab->ovl_sec[i];
1678       unsigned int ovl = spu_elf_section_data (osec)->u.o.ovl_index;
1679       stub = bfd_make_section_anyway_with_flags (ibfd, ".stub", flags);
1680       htab->stub_sec[ovl] = stub;
1681       if (stub == NULL
1682           || !bfd_set_section_alignment (ibfd, stub,
1683                                          ovl_stub_size_log2 (htab->params)))
1684         return 0;
1685       stub->size = htab->stub_count[ovl] * ovl_stub_size (htab->params);
1686     }
1687
1688   if (htab->params->ovly_flavour == ovly_soft_icache)
1689     {
1690       /* Space for icache manager tables.
1691          a) Tag array, one quadword per cache line.
1692          b) Rewrite "to" list, one quadword per cache line.
1693          c) Rewrite "from" list, one byte per outgoing branch (rounded up to
1694             a power-of-two number of full quadwords) per cache line.  */
1695
1696       flags = SEC_ALLOC;
1697       htab->ovtab = bfd_make_section_anyway_with_flags (ibfd, ".ovtab", flags);
1698       if (htab->ovtab == NULL
1699           || !bfd_set_section_alignment (ibfd, htab->ovtab, 4))
1700         return 0;
1701
1702       htab->ovtab->size = (16 + 16 + (16 << htab->fromelem_size_log2))
1703                           << htab->num_lines_log2;
1704
1705       flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
1706       htab->init = bfd_make_section_anyway_with_flags (ibfd, ".ovini", flags);
1707       if (htab->init == NULL
1708           || !bfd_set_section_alignment (ibfd, htab->init, 4))
1709         return 0;
1710
1711       htab->init->size = 16;
1712     }
1713   else
1714     {
1715       /* htab->ovtab consists of two arrays.
1716          .      struct {
1717          .        u32 vma;
1718          .        u32 size;
1719          .        u32 file_off;
1720          .        u32 buf;
1721          .      } _ovly_table[];
1722          .
1723          .      struct {
1724          .        u32 mapped;
1725          .      } _ovly_buf_table[];
1726          .  */
1727
1728       flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
1729       htab->ovtab = bfd_make_section_anyway_with_flags (ibfd, ".ovtab", flags);
1730       if (htab->ovtab == NULL
1731           || !bfd_set_section_alignment (ibfd, htab->ovtab, 4))
1732         return 0;
1733
1734       htab->ovtab->size = htab->num_overlays * 16 + 16 + htab->num_buf * 4;
1735     }
1736
1737   htab->toe = bfd_make_section_anyway_with_flags (ibfd, ".toe", SEC_ALLOC);
1738   if (htab->toe == NULL
1739       || !bfd_set_section_alignment (ibfd, htab->toe, 4))
1740     return 0;
1741   htab->toe->size = 16;
1742
1743   return 2;
1744 }
1745
1746 /* Called from ld to place overlay manager data sections.  This is done
1747    after the overlay manager itself is loaded, mainly so that the
1748    linker's htab->init section is placed after any other .ovl.init
1749    sections.  */
1750
1751 void
1752 spu_elf_place_overlay_data (struct bfd_link_info *info)
1753 {
1754   struct spu_link_hash_table *htab = spu_hash_table (info);
1755   unsigned int i;
1756   const char *ovout;
1757
1758   if (htab->stub_count == NULL)
1759     return;
1760
1761   (*htab->params->place_spu_section) (htab->stub_sec[0], NULL, ".text");
1762
1763   for (i = 0; i < htab->num_overlays; ++i)
1764     {
1765       asection *osec = htab->ovl_sec[i];
1766       unsigned int ovl = spu_elf_section_data (osec)->u.o.ovl_index;
1767       (*htab->params->place_spu_section) (htab->stub_sec[ovl], osec, NULL);
1768     }
1769
1770   if (htab->params->ovly_flavour == ovly_soft_icache)
1771     (*htab->params->place_spu_section) (htab->init, NULL, ".ovl.init");
1772
1773   ovout = ".data";
1774   if (htab->params->ovly_flavour == ovly_soft_icache)
1775     ovout = ".bss";
1776   (*htab->params->place_spu_section) (htab->ovtab, NULL, ovout);
1777
1778   (*htab->params->place_spu_section) (htab->toe, NULL, ".toe");
1779 }
1780
1781 /* Functions to handle embedded spu_ovl.o object.  */
1782
1783 static void *
1784 ovl_mgr_open (struct bfd *nbfd ATTRIBUTE_UNUSED, void *stream)
1785 {
1786   return stream;
1787 }
1788
1789 static file_ptr
1790 ovl_mgr_pread (struct bfd *abfd ATTRIBUTE_UNUSED,
1791                void *stream,
1792                void *buf,
1793                file_ptr nbytes,
1794                file_ptr offset)
1795 {
1796   struct _ovl_stream *os;
1797   size_t count;
1798   size_t max;
1799
1800   os = (struct _ovl_stream *) stream;
1801   max = (const char *) os->end - (const char *) os->start;
1802
1803   if ((ufile_ptr) offset >= max)
1804     return 0;
1805
1806   count = nbytes;
1807   if (count > max - offset)
1808     count = max - offset;
1809
1810   memcpy (buf, (const char *) os->start + offset, count);
1811   return count;
1812 }
1813
1814 bfd_boolean
1815 spu_elf_open_builtin_lib (bfd **ovl_bfd, const struct _ovl_stream *stream)
1816 {
1817   *ovl_bfd = bfd_openr_iovec ("builtin ovl_mgr",
1818                               "elf32-spu",
1819                               ovl_mgr_open,
1820                               (void *) stream,
1821                               ovl_mgr_pread,
1822                               NULL,
1823                               NULL);
1824   return *ovl_bfd != NULL;
1825 }
1826
1827 static unsigned int
1828 overlay_index (asection *sec)
1829 {
1830   if (sec == NULL
1831       || sec->output_section == bfd_abs_section_ptr)
1832     return 0;
1833   return spu_elf_section_data (sec->output_section)->u.o.ovl_index;
1834 }
1835
1836 /* Define an STT_OBJECT symbol.  */
1837
1838 static struct elf_link_hash_entry *
1839 define_ovtab_symbol (struct spu_link_hash_table *htab, const char *name)
1840 {
1841   struct elf_link_hash_entry *h;
1842
1843   h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
1844   if (h == NULL)
1845     return NULL;
1846
1847   if (h->root.type != bfd_link_hash_defined
1848       || !h->def_regular)
1849     {
1850       h->root.type = bfd_link_hash_defined;
1851       h->root.u.def.section = htab->ovtab;
1852       h->type = STT_OBJECT;
1853       h->ref_regular = 1;
1854       h->def_regular = 1;
1855       h->ref_regular_nonweak = 1;
1856       h->non_elf = 0;
1857     }
1858   else if (h->root.u.def.section->owner != NULL)
1859     {
1860       (*_bfd_error_handler) (_("%B is not allowed to define %s"),
1861                              h->root.u.def.section->owner,
1862                              h->root.root.string);
1863       bfd_set_error (bfd_error_bad_value);
1864       return NULL;
1865     }
1866   else
1867     {
1868       (*_bfd_error_handler) (_("you are not allowed to define %s in a script"),
1869                              h->root.root.string);
1870       bfd_set_error (bfd_error_bad_value);
1871       return NULL;
1872     }
1873
1874   return h;
1875 }
1876
1877 /* Fill in all stubs and the overlay tables.  */
1878
1879 static bfd_boolean
1880 spu_elf_build_stubs (struct bfd_link_info *info)
1881 {
1882   struct spu_link_hash_table *htab = spu_hash_table (info);
1883   struct elf_link_hash_entry *h;
1884   bfd_byte *p;
1885   asection *s;
1886   bfd *obfd;
1887   unsigned int i;
1888
1889   if (htab->stub_count == NULL)
1890     return TRUE;
1891
1892   for (i = 0; i <= htab->num_overlays; i++)
1893     if (htab->stub_sec[i]->size != 0)
1894       {
1895         htab->stub_sec[i]->contents = bfd_zalloc (htab->stub_sec[i]->owner,
1896                                                   htab->stub_sec[i]->size);
1897         if (htab->stub_sec[i]->contents == NULL)
1898           return FALSE;
1899         htab->stub_sec[i]->rawsize = htab->stub_sec[i]->size;
1900         htab->stub_sec[i]->size = 0;
1901       }
1902
1903   for (i = 0; i < 2; i++)
1904     {
1905       h = htab->ovly_entry[i];
1906       BFD_ASSERT (h != NULL);
1907
1908       if ((h->root.type == bfd_link_hash_defined
1909            || h->root.type == bfd_link_hash_defweak)
1910           && h->def_regular)
1911         {
1912           s = h->root.u.def.section->output_section;
1913           if (spu_elf_section_data (s)->u.o.ovl_index)
1914             {
1915               (*_bfd_error_handler) (_("%s in overlay section"),
1916                                      h->root.root.string);
1917               bfd_set_error (bfd_error_bad_value);
1918               return FALSE;
1919             }
1920         }
1921       else
1922         BFD_ASSERT (0);
1923     }
1924
1925   /* Fill in all the stubs.  */
1926   process_stubs (info, TRUE);
1927   if (!htab->stub_err)
1928     elf_link_hash_traverse (&htab->elf, build_spuear_stubs, info);
1929
1930   if (htab->stub_err)
1931     {
1932       (*_bfd_error_handler) (_("overlay stub relocation overflow"));
1933       bfd_set_error (bfd_error_bad_value);
1934       return FALSE;
1935     }
1936
1937   for (i = 0; i <= htab->num_overlays; i++)
1938     {
1939       if (htab->stub_sec[i]->size != htab->stub_sec[i]->rawsize)
1940         {
1941           (*_bfd_error_handler)  (_("stubs don't match calculated size"));
1942           bfd_set_error (bfd_error_bad_value);
1943           return FALSE;
1944         }
1945       htab->stub_sec[i]->rawsize = 0;
1946     }
1947
1948   if (htab->ovtab == NULL || htab->ovtab->size == 0)
1949     return TRUE;
1950
1951   htab->ovtab->contents = bfd_zalloc (htab->ovtab->owner, htab->ovtab->size);
1952   if (htab->ovtab->contents == NULL)
1953     return FALSE;
1954
1955   p = htab->ovtab->contents;
1956   if (htab->params->ovly_flavour == ovly_soft_icache)
1957     {
1958       bfd_vma off;
1959
1960       h = define_ovtab_symbol (htab, "__icache_tag_array");
1961       if (h == NULL)
1962         return FALSE;
1963       h->root.u.def.value = 0;
1964       h->size = 16 << htab->num_lines_log2;
1965       off = h->size;
1966
1967       h = define_ovtab_symbol (htab, "__icache_tag_array_size");
1968       if (h == NULL)
1969         return FALSE;
1970       h->root.u.def.value = 16 << htab->num_lines_log2;
1971       h->root.u.def.section = bfd_abs_section_ptr;
1972
1973       h = define_ovtab_symbol (htab, "__icache_rewrite_to");
1974       if (h == NULL)
1975         return FALSE;
1976       h->root.u.def.value = off;
1977       h->size = 16 << htab->num_lines_log2;
1978       off += h->size;
1979
1980       h = define_ovtab_symbol (htab, "__icache_rewrite_to_size");
1981       if (h == NULL)
1982         return FALSE;
1983       h->root.u.def.value = 16 << htab->num_lines_log2;
1984       h->root.u.def.section = bfd_abs_section_ptr;
1985
1986       h = define_ovtab_symbol (htab, "__icache_rewrite_from");
1987       if (h == NULL)
1988         return FALSE;
1989       h->root.u.def.value = off;
1990       h->size = 16 << (htab->fromelem_size_log2 + htab->num_lines_log2);
1991       off += h->size;
1992
1993       h = define_ovtab_symbol (htab, "__icache_rewrite_from_size");
1994       if (h == NULL)
1995         return FALSE;
1996       h->root.u.def.value = 16 << (htab->fromelem_size_log2
1997                                    + htab->num_lines_log2);
1998       h->root.u.def.section = bfd_abs_section_ptr;
1999
2000       h = define_ovtab_symbol (htab, "__icache_log2_fromelemsize");
2001       if (h == NULL)
2002         return FALSE;
2003       h->root.u.def.value = htab->fromelem_size_log2;
2004       h->root.u.def.section = bfd_abs_section_ptr;
2005
2006       h = define_ovtab_symbol (htab, "__icache_base");
2007       if (h == NULL)
2008         return FALSE;
2009       h->root.u.def.value = htab->ovl_sec[0]->vma;
2010       h->root.u.def.section = bfd_abs_section_ptr;
2011       h->size = htab->num_buf << htab->line_size_log2;
2012
2013       h = define_ovtab_symbol (htab, "__icache_linesize");
2014       if (h == NULL)
2015         return FALSE;
2016       h->root.u.def.value = 1 << htab->line_size_log2;
2017       h->root.u.def.section = bfd_abs_section_ptr;
2018
2019       h = define_ovtab_symbol (htab, "__icache_log2_linesize");
2020       if (h == NULL)
2021         return FALSE;
2022       h->root.u.def.value = htab->line_size_log2;
2023       h->root.u.def.section = bfd_abs_section_ptr;
2024
2025       h = define_ovtab_symbol (htab, "__icache_neg_log2_linesize");
2026       if (h == NULL)
2027         return FALSE;
2028       h->root.u.def.value = -htab->line_size_log2;
2029       h->root.u.def.section = bfd_abs_section_ptr;
2030
2031       h = define_ovtab_symbol (htab, "__icache_cachesize");
2032       if (h == NULL)
2033         return FALSE;
2034       h->root.u.def.value = 1 << (htab->num_lines_log2 + htab->line_size_log2);
2035       h->root.u.def.section = bfd_abs_section_ptr;
2036
2037       h = define_ovtab_symbol (htab, "__icache_log2_cachesize");
2038       if (h == NULL)
2039         return FALSE;
2040       h->root.u.def.value = htab->num_lines_log2 + htab->line_size_log2;
2041       h->root.u.def.section = bfd_abs_section_ptr;
2042
2043       h = define_ovtab_symbol (htab, "__icache_neg_log2_cachesize");
2044       if (h == NULL)
2045         return FALSE;
2046       h->root.u.def.value = -(htab->num_lines_log2 + htab->line_size_log2);
2047       h->root.u.def.section = bfd_abs_section_ptr;
2048
2049       if (htab->init != NULL && htab->init->size != 0)
2050         {
2051           htab->init->contents = bfd_zalloc (htab->init->owner,
2052                                              htab->init->size);
2053           if (htab->init->contents == NULL)
2054             return FALSE;
2055
2056           h = define_ovtab_symbol (htab, "__icache_fileoff");
2057           if (h == NULL)
2058             return FALSE;
2059           h->root.u.def.value = 0;
2060           h->root.u.def.section = htab->init;
2061           h->size = 8;
2062         }
2063     }
2064   else
2065     {
2066       /* Write out _ovly_table.  */
2067       /* set low bit of .size to mark non-overlay area as present.  */
2068       p[7] = 1;
2069       obfd = htab->ovtab->output_section->owner;
2070       for (s = obfd->sections; s != NULL; s = s->next)
2071         {
2072           unsigned int ovl_index = spu_elf_section_data (s)->u.o.ovl_index;
2073
2074           if (ovl_index != 0)
2075             {
2076               unsigned long off = ovl_index * 16;
2077               unsigned int ovl_buf = spu_elf_section_data (s)->u.o.ovl_buf;
2078
2079               bfd_put_32 (htab->ovtab->owner, s->vma, p + off);
2080               bfd_put_32 (htab->ovtab->owner, (s->size + 15) & -16,
2081                           p + off + 4);
2082               /* file_off written later in spu_elf_modify_program_headers.  */
2083               bfd_put_32 (htab->ovtab->owner, ovl_buf, p + off + 12);
2084             }
2085         }
2086
2087       h = define_ovtab_symbol (htab, "_ovly_table");
2088       if (h == NULL)
2089         return FALSE;
2090       h->root.u.def.value = 16;
2091       h->size = htab->num_overlays * 16;
2092
2093       h = define_ovtab_symbol (htab, "_ovly_table_end");
2094       if (h == NULL)
2095         return FALSE;
2096       h->root.u.def.value = htab->num_overlays * 16 + 16;
2097       h->size = 0;
2098
2099       h = define_ovtab_symbol (htab, "_ovly_buf_table");
2100       if (h == NULL)
2101         return FALSE;
2102       h->root.u.def.value = htab->num_overlays * 16 + 16;
2103       h->size = htab->num_buf * 4;
2104
2105       h = define_ovtab_symbol (htab, "_ovly_buf_table_end");
2106       if (h == NULL)
2107         return FALSE;
2108       h->root.u.def.value = htab->num_overlays * 16 + 16 + htab->num_buf * 4;
2109       h->size = 0;
2110     }
2111
2112   h = define_ovtab_symbol (htab, "_EAR_");
2113   if (h == NULL)
2114     return FALSE;
2115   h->root.u.def.section = htab->toe;
2116   h->root.u.def.value = 0;
2117   h->size = 16;
2118
2119   return TRUE;
2120 }
2121
2122 /* Check that all loadable section VMAs lie in the range
2123    LO .. HI inclusive, and stash some parameters for --auto-overlay.  */
2124
2125 asection *
2126 spu_elf_check_vma (struct bfd_link_info *info)
2127 {
2128   struct elf_segment_map *m;
2129   unsigned int i;
2130   struct spu_link_hash_table *htab = spu_hash_table (info);
2131   bfd *abfd = info->output_bfd;
2132   bfd_vma hi = htab->params->local_store_hi;
2133   bfd_vma lo = htab->params->local_store_lo;
2134
2135   htab->local_store = hi + 1 - lo;
2136
2137   for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
2138     if (m->p_type == PT_LOAD)
2139       for (i = 0; i < m->count; i++)
2140         if (m->sections[i]->size != 0
2141             && (m->sections[i]->vma < lo
2142                 || m->sections[i]->vma > hi
2143                 || m->sections[i]->vma + m->sections[i]->size - 1 > hi))
2144           return m->sections[i];
2145
2146   return NULL;
2147 }
2148
2149 /* OFFSET in SEC (presumably) is the beginning of a function prologue.
2150    Search for stack adjusting insns, and return the sp delta.
2151    If a store of lr is found save the instruction offset to *LR_STORE.
2152    If a stack adjusting instruction is found, save that offset to
2153    *SP_ADJUST.  */
2154
2155 static int
2156 find_function_stack_adjust (asection *sec,
2157                             bfd_vma offset,
2158                             bfd_vma *lr_store,
2159                             bfd_vma *sp_adjust)
2160 {
2161   int reg[128];
2162
2163   memset (reg, 0, sizeof (reg));
2164   for ( ; offset + 4 <= sec->size; offset += 4)
2165     {
2166       unsigned char buf[4];
2167       int rt, ra;
2168       int imm;
2169
2170       /* Assume no relocs on stack adjusing insns.  */
2171       if (!bfd_get_section_contents (sec->owner, sec, buf, offset, 4))
2172         break;
2173
2174       rt = buf[3] & 0x7f;
2175       ra = ((buf[2] & 0x3f) << 1) | (buf[3] >> 7);
2176
2177       if (buf[0] == 0x24 /* stqd */)
2178         {
2179           if (rt == 0 /* lr */ && ra == 1 /* sp */)
2180             *lr_store = offset;
2181           continue;
2182         }
2183
2184       /* Partly decoded immediate field.  */
2185       imm = (buf[1] << 9) | (buf[2] << 1) | (buf[3] >> 7);
2186
2187       if (buf[0] == 0x1c /* ai */)
2188         {
2189           imm >>= 7;
2190           imm = (imm ^ 0x200) - 0x200;
2191           reg[rt] = reg[ra] + imm;
2192
2193           if (rt == 1 /* sp */)
2194             {
2195               if (reg[rt] > 0)
2196                 break;
2197               *sp_adjust = offset;
2198               return reg[rt];
2199             }
2200         }
2201       else if (buf[0] == 0x18 && (buf[1] & 0xe0) == 0 /* a */)
2202         {
2203           int rb = ((buf[1] & 0x1f) << 2) | ((buf[2] & 0xc0) >> 6);
2204
2205           reg[rt] = reg[ra] + reg[rb];
2206           if (rt == 1)
2207             {
2208               if (reg[rt] > 0)
2209                 break;
2210               *sp_adjust = offset;
2211               return reg[rt];
2212             }
2213         }
2214       else if (buf[0] == 0x08 && (buf[1] & 0xe0) == 0 /* sf */)
2215         {
2216           int rb = ((buf[1] & 0x1f) << 2) | ((buf[2] & 0xc0) >> 6);
2217
2218           reg[rt] = reg[rb] - reg[ra];
2219           if (rt == 1)
2220             {
2221               if (reg[rt] > 0)
2222                 break;
2223               *sp_adjust = offset;
2224               return reg[rt];
2225             }
2226         }
2227       else if ((buf[0] & 0xfc) == 0x40 /* il, ilh, ilhu, ila */)
2228         {
2229           if (buf[0] >= 0x42 /* ila */)
2230             imm |= (buf[0] & 1) << 17;
2231           else
2232             {
2233               imm &= 0xffff;
2234
2235               if (buf[0] == 0x40 /* il */)
2236                 {
2237                   if ((buf[1] & 0x80) == 0)
2238                     continue;
2239                   imm = (imm ^ 0x8000) - 0x8000;
2240                 }
2241               else if ((buf[1] & 0x80) == 0 /* ilhu */)
2242                 imm <<= 16;
2243             }
2244           reg[rt] = imm;
2245           continue;
2246         }
2247       else if (buf[0] == 0x60 && (buf[1] & 0x80) != 0 /* iohl */)
2248         {
2249           reg[rt] |= imm & 0xffff;
2250           continue;
2251         }
2252       else if (buf[0] == 0x04 /* ori */)
2253         {
2254           imm >>= 7;
2255           imm = (imm ^ 0x200) - 0x200;
2256           reg[rt] = reg[ra] | imm;
2257           continue;
2258         }
2259       else if (buf[0] == 0x32 && (buf[1] & 0x80) != 0 /* fsmbi */)
2260         {
2261           reg[rt] = (  ((imm & 0x8000) ? 0xff000000 : 0)
2262                      | ((imm & 0x4000) ? 0x00ff0000 : 0)
2263                      | ((imm & 0x2000) ? 0x0000ff00 : 0)
2264                      | ((imm & 0x1000) ? 0x000000ff : 0));
2265           continue;
2266         }
2267       else if (buf[0] == 0x16 /* andbi */)
2268         {
2269           imm >>= 7;
2270           imm &= 0xff;
2271           imm |= imm << 8;
2272           imm |= imm << 16;
2273           reg[rt] = reg[ra] & imm;
2274           continue;
2275         }
2276       else if (buf[0] == 0x33 && imm == 1 /* brsl .+4 */)
2277         {
2278           /* Used in pic reg load.  Say rt is trashed.  Won't be used
2279              in stack adjust, but we need to continue past this branch.  */
2280           reg[rt] = 0;
2281           continue;
2282         }
2283       else if (is_branch (buf) || is_indirect_branch (buf))
2284         /* If we hit a branch then we must be out of the prologue.  */
2285         break;
2286     }
2287
2288   return 0;
2289 }
2290
2291 /* qsort predicate to sort symbols by section and value.  */
2292
2293 static Elf_Internal_Sym *sort_syms_syms;
2294 static asection **sort_syms_psecs;
2295
2296 static int
2297 sort_syms (const void *a, const void *b)
2298 {
2299   Elf_Internal_Sym *const *s1 = a;
2300   Elf_Internal_Sym *const *s2 = b;
2301   asection *sec1,*sec2;
2302   bfd_signed_vma delta;
2303
2304   sec1 = sort_syms_psecs[*s1 - sort_syms_syms];
2305   sec2 = sort_syms_psecs[*s2 - sort_syms_syms];
2306
2307   if (sec1 != sec2)
2308     return sec1->index - sec2->index;
2309
2310   delta = (*s1)->st_value - (*s2)->st_value;
2311   if (delta != 0)
2312     return delta < 0 ? -1 : 1;
2313
2314   delta = (*s2)->st_size - (*s1)->st_size;
2315   if (delta != 0)
2316     return delta < 0 ? -1 : 1;
2317
2318   return *s1 < *s2 ? -1 : 1;
2319 }
2320
2321 /* Allocate a struct spu_elf_stack_info with MAX_FUN struct function_info
2322    entries for section SEC.  */
2323
2324 static struct spu_elf_stack_info *
2325 alloc_stack_info (asection *sec, int max_fun)
2326 {
2327   struct _spu_elf_section_data *sec_data = spu_elf_section_data (sec);
2328   bfd_size_type amt;
2329
2330   amt = sizeof (struct spu_elf_stack_info);
2331   amt += (max_fun - 1) * sizeof (struct function_info);
2332   sec_data->u.i.stack_info = bfd_zmalloc (amt);
2333   if (sec_data->u.i.stack_info != NULL)
2334     sec_data->u.i.stack_info->max_fun = max_fun;
2335   return sec_data->u.i.stack_info;
2336 }
2337
2338 /* Add a new struct function_info describing a (part of a) function
2339    starting at SYM_H.  Keep the array sorted by address.  */
2340
2341 static struct function_info *
2342 maybe_insert_function (asection *sec,
2343                        void *sym_h,
2344                        bfd_boolean global,
2345                        bfd_boolean is_func)
2346 {
2347   struct _spu_elf_section_data *sec_data = spu_elf_section_data (sec);
2348   struct spu_elf_stack_info *sinfo = sec_data->u.i.stack_info;
2349   int i;
2350   bfd_vma off, size;
2351
2352   if (sinfo == NULL)
2353     {
2354       sinfo = alloc_stack_info (sec, 20);
2355       if (sinfo == NULL)
2356         return NULL;
2357     }
2358
2359   if (!global)
2360     {
2361       Elf_Internal_Sym *sym = sym_h;
2362       off = sym->st_value;
2363       size = sym->st_size;
2364     }
2365   else
2366     {
2367       struct elf_link_hash_entry *h = sym_h;
2368       off = h->root.u.def.value;
2369       size = h->size;
2370     }
2371
2372   for (i = sinfo->num_fun; --i >= 0; )
2373     if (sinfo->fun[i].lo <= off)
2374       break;
2375
2376   if (i >= 0)
2377     {
2378       /* Don't add another entry for an alias, but do update some
2379          info.  */
2380       if (sinfo->fun[i].lo == off)
2381         {
2382           /* Prefer globals over local syms.  */
2383           if (global && !sinfo->fun[i].global)
2384             {
2385               sinfo->fun[i].global = TRUE;
2386               sinfo->fun[i].u.h = sym_h;
2387             }
2388           if (is_func)
2389             sinfo->fun[i].is_func = TRUE;
2390           return &sinfo->fun[i];
2391         }
2392       /* Ignore a zero-size symbol inside an existing function.  */
2393       else if (sinfo->fun[i].hi > off && size == 0)
2394         return &sinfo->fun[i];
2395     }
2396
2397   if (sinfo->num_fun >= sinfo->max_fun)
2398     {
2399       bfd_size_type amt = sizeof (struct spu_elf_stack_info);
2400       bfd_size_type old = amt;
2401
2402       old += (sinfo->max_fun - 1) * sizeof (struct function_info);
2403       sinfo->max_fun += 20 + (sinfo->max_fun >> 1);
2404       amt += (sinfo->max_fun - 1) * sizeof (struct function_info);
2405       sinfo = bfd_realloc (sinfo, amt);
2406       if (sinfo == NULL)
2407         return NULL;
2408       memset ((char *) sinfo + old, 0, amt - old);
2409       sec_data->u.i.stack_info = sinfo;
2410     }
2411
2412   if (++i < sinfo->num_fun)
2413     memmove (&sinfo->fun[i + 1], &sinfo->fun[i],
2414              (sinfo->num_fun - i) * sizeof (sinfo->fun[i]));
2415   sinfo->fun[i].is_func = is_func;
2416   sinfo->fun[i].global = global;
2417   sinfo->fun[i].sec = sec;
2418   if (global)
2419     sinfo->fun[i].u.h = sym_h;
2420   else
2421     sinfo->fun[i].u.sym = sym_h;
2422   sinfo->fun[i].lo = off;
2423   sinfo->fun[i].hi = off + size;
2424   sinfo->fun[i].lr_store = -1;
2425   sinfo->fun[i].sp_adjust = -1;
2426   sinfo->fun[i].stack = -find_function_stack_adjust (sec, off,
2427                                                      &sinfo->fun[i].lr_store,
2428                                                      &sinfo->fun[i].sp_adjust);
2429   sinfo->num_fun += 1;
2430   return &sinfo->fun[i];
2431 }
2432
2433 /* Return the name of FUN.  */
2434
2435 static const char *
2436 func_name (struct function_info *fun)
2437 {
2438   asection *sec;
2439   bfd *ibfd;
2440   Elf_Internal_Shdr *symtab_hdr;
2441
2442   while (fun->start != NULL)
2443     fun = fun->start;
2444
2445   if (fun->global)
2446     return fun->u.h->root.root.string;
2447
2448   sec = fun->sec;
2449   if (fun->u.sym->st_name == 0)
2450     {
2451       size_t len = strlen (sec->name);
2452       char *name = bfd_malloc (len + 10);
2453       if (name == NULL)
2454         return "(null)";
2455       sprintf (name, "%s+%lx", sec->name,
2456                (unsigned long) fun->u.sym->st_value & 0xffffffff);
2457       return name;
2458     }
2459   ibfd = sec->owner;
2460   symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2461   return bfd_elf_sym_name (ibfd, symtab_hdr, fun->u.sym, sec);
2462 }
2463
2464 /* Read the instruction at OFF in SEC.  Return true iff the instruction
2465    is a nop, lnop, or stop 0 (all zero insn).  */
2466
2467 static bfd_boolean
2468 is_nop (asection *sec, bfd_vma off)
2469 {
2470   unsigned char insn[4];
2471
2472   if (off + 4 > sec->size
2473       || !bfd_get_section_contents (sec->owner, sec, insn, off, 4))
2474     return FALSE;
2475   if ((insn[0] & 0xbf) == 0 && (insn[1] & 0xe0) == 0x20)
2476     return TRUE;
2477   if (insn[0] == 0 && insn[1] == 0 && insn[2] == 0 && insn[3] == 0)
2478     return TRUE;
2479   return FALSE;
2480 }
2481
2482 /* Extend the range of FUN to cover nop padding up to LIMIT.
2483    Return TRUE iff some instruction other than a NOP was found.  */
2484
2485 static bfd_boolean
2486 insns_at_end (struct function_info *fun, bfd_vma limit)
2487 {
2488   bfd_vma off = (fun->hi + 3) & -4;
2489
2490   while (off < limit && is_nop (fun->sec, off))
2491     off += 4;
2492   if (off < limit)
2493     {
2494       fun->hi = off;
2495       return TRUE;
2496     }
2497   fun->hi = limit;
2498   return FALSE;
2499 }
2500
2501 /* Check and fix overlapping function ranges.  Return TRUE iff there
2502    are gaps in the current info we have about functions in SEC.  */
2503
2504 static bfd_boolean
2505 check_function_ranges (asection *sec, struct bfd_link_info *info)
2506 {
2507   struct _spu_elf_section_data *sec_data = spu_elf_section_data (sec);
2508   struct spu_elf_stack_info *sinfo = sec_data->u.i.stack_info;
2509   int i;
2510   bfd_boolean gaps = FALSE;
2511
2512   if (sinfo == NULL)
2513     return FALSE;
2514
2515   for (i = 1; i < sinfo->num_fun; i++)
2516     if (sinfo->fun[i - 1].hi > sinfo->fun[i].lo)
2517       {
2518         /* Fix overlapping symbols.  */
2519         const char *f1 = func_name (&sinfo->fun[i - 1]);
2520         const char *f2 = func_name (&sinfo->fun[i]);
2521
2522         info->callbacks->einfo (_("warning: %s overlaps %s\n"), f1, f2);
2523         sinfo->fun[i - 1].hi = sinfo->fun[i].lo;
2524       }
2525     else if (insns_at_end (&sinfo->fun[i - 1], sinfo->fun[i].lo))
2526       gaps = TRUE;
2527
2528   if (sinfo->num_fun == 0)
2529     gaps = TRUE;
2530   else
2531     {
2532       if (sinfo->fun[0].lo != 0)
2533         gaps = TRUE;
2534       if (sinfo->fun[sinfo->num_fun - 1].hi > sec->size)
2535         {
2536           const char *f1 = func_name (&sinfo->fun[sinfo->num_fun - 1]);
2537
2538           info->callbacks->einfo (_("warning: %s exceeds section size\n"), f1);
2539           sinfo->fun[sinfo->num_fun - 1].hi = sec->size;
2540         }
2541       else if (insns_at_end (&sinfo->fun[sinfo->num_fun - 1], sec->size))
2542         gaps = TRUE;
2543     }
2544   return gaps;
2545 }
2546
2547 /* Search current function info for a function that contains address
2548    OFFSET in section SEC.  */
2549
2550 static struct function_info *
2551 find_function (asection *sec, bfd_vma offset, struct bfd_link_info *info)
2552 {
2553   struct _spu_elf_section_data *sec_data = spu_elf_section_data (sec);
2554   struct spu_elf_stack_info *sinfo = sec_data->u.i.stack_info;
2555   int lo, hi, mid;
2556
2557   lo = 0;
2558   hi = sinfo->num_fun;
2559   while (lo < hi)
2560     {
2561       mid = (lo + hi) / 2;
2562       if (offset < sinfo->fun[mid].lo)
2563         hi = mid;
2564       else if (offset >= sinfo->fun[mid].hi)
2565         lo = mid + 1;
2566       else
2567         return &sinfo->fun[mid];
2568     }
2569   info->callbacks->einfo (_("%A:0x%v not found in function table\n"),
2570                           sec, offset);
2571   bfd_set_error (bfd_error_bad_value);
2572   return NULL;
2573 }
2574
2575 /* Add CALLEE to CALLER call list if not already present.  Return TRUE
2576    if CALLEE was new.  If this function return FALSE, CALLEE should
2577    be freed.  */
2578
2579 static bfd_boolean
2580 insert_callee (struct function_info *caller, struct call_info *callee)
2581 {
2582   struct call_info **pp, *p;
2583
2584   for (pp = &caller->call_list; (p = *pp) != NULL; pp = &p->next)
2585     if (p->fun == callee->fun)
2586       {
2587         /* Tail calls use less stack than normal calls.  Retain entry
2588            for normal call over one for tail call.  */
2589         p->is_tail &= callee->is_tail;
2590         if (!p->is_tail)
2591           {
2592             p->fun->start = NULL;
2593             p->fun->is_func = TRUE;
2594           }
2595         p->count += 1;
2596         /* Reorder list so most recent call is first.  */
2597         *pp = p->next;
2598         p->next = caller->call_list;
2599         caller->call_list = p;
2600         return FALSE;
2601       }
2602   callee->next = caller->call_list;
2603   callee->count += 1;
2604   caller->call_list = callee;
2605   return TRUE;
2606 }
2607
2608 /* Copy CALL and insert the copy into CALLER.  */
2609
2610 static bfd_boolean
2611 copy_callee (struct function_info *caller, const struct call_info *call)
2612 {
2613   struct call_info *callee;
2614   callee = bfd_malloc (sizeof (*callee));
2615   if (callee == NULL)
2616     return FALSE;
2617   *callee = *call;
2618   if (!insert_callee (caller, callee))
2619     free (callee);
2620   return TRUE;
2621 }
2622
2623 /* We're only interested in code sections.  Testing SEC_IN_MEMORY excludes
2624    overlay stub sections.  */
2625
2626 static bfd_boolean
2627 interesting_section (asection *s)
2628 {
2629   return (s->output_section != bfd_abs_section_ptr
2630           && ((s->flags & (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_IN_MEMORY))
2631               == (SEC_ALLOC | SEC_LOAD | SEC_CODE))
2632           && s->size != 0);
2633 }
2634
2635 /* Rummage through the relocs for SEC, looking for function calls.
2636    If CALL_TREE is true, fill in call graph.  If CALL_TREE is false,
2637    mark destination symbols on calls as being functions.  Also
2638    look at branches, which may be tail calls or go to hot/cold
2639    section part of same function.  */
2640
2641 static bfd_boolean
2642 mark_functions_via_relocs (asection *sec,
2643                            struct bfd_link_info *info,
2644                            int call_tree)
2645 {
2646   Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
2647   Elf_Internal_Shdr *symtab_hdr;
2648   void *psyms;
2649   unsigned int priority = 0;
2650   static bfd_boolean warned;
2651
2652   if (!interesting_section (sec)
2653       || sec->reloc_count == 0)
2654     return TRUE;
2655
2656   internal_relocs = _bfd_elf_link_read_relocs (sec->owner, sec, NULL, NULL,
2657                                                info->keep_memory);
2658   if (internal_relocs == NULL)
2659     return FALSE;
2660
2661   symtab_hdr = &elf_tdata (sec->owner)->symtab_hdr;
2662   psyms = &symtab_hdr->contents;
2663   irela = internal_relocs;
2664   irelaend = irela + sec->reloc_count;
2665   for (; irela < irelaend; irela++)
2666     {
2667       enum elf_spu_reloc_type r_type;
2668       unsigned int r_indx;
2669       asection *sym_sec;
2670       Elf_Internal_Sym *sym;
2671       struct elf_link_hash_entry *h;
2672       bfd_vma val;
2673       bfd_boolean reject, is_call;
2674       struct function_info *caller;
2675       struct call_info *callee;
2676
2677       reject = FALSE;
2678       r_type = ELF32_R_TYPE (irela->r_info);
2679       if (r_type != R_SPU_REL16
2680           && r_type != R_SPU_ADDR16)
2681         {
2682           reject = TRUE;
2683           if (!(call_tree && spu_hash_table (info)->params->auto_overlay))
2684             continue;
2685         }
2686
2687       r_indx = ELF32_R_SYM (irela->r_info);
2688       if (!get_sym_h (&h, &sym, &sym_sec, psyms, r_indx, sec->owner))
2689         return FALSE;
2690
2691       if (sym_sec == NULL
2692           || sym_sec->output_section == bfd_abs_section_ptr)
2693         continue;
2694
2695       is_call = FALSE;
2696       if (!reject)
2697         {
2698           unsigned char insn[4];
2699
2700           if (!bfd_get_section_contents (sec->owner, sec, insn,
2701                                          irela->r_offset, 4))
2702             return FALSE;
2703           if (is_branch (insn))
2704             {
2705               is_call = (insn[0] & 0xfd) == 0x31;
2706               priority = insn[1] & 0x0f;
2707               priority <<= 8;
2708               priority |= insn[2];
2709               priority <<= 8;
2710               priority |= insn[3];
2711               priority >>= 7;
2712               if ((sym_sec->flags & (SEC_ALLOC | SEC_LOAD | SEC_CODE))
2713                   != (SEC_ALLOC | SEC_LOAD | SEC_CODE))
2714                 {
2715                   if (!warned)
2716                     info->callbacks->einfo
2717                       (_("%B(%A+0x%v): call to non-code section"
2718                          " %B(%A), analysis incomplete\n"),
2719                        sec->owner, sec, irela->r_offset,
2720                        sym_sec->owner, sym_sec);
2721                   warned = TRUE;
2722                   continue;
2723                 }
2724             }
2725           else
2726             {
2727               reject = TRUE;
2728               if (!(call_tree && spu_hash_table (info)->params->auto_overlay)
2729                   || is_hint (insn))
2730                 continue;
2731             }
2732         }
2733
2734       if (reject)
2735         {
2736           /* For --auto-overlay, count possible stubs we need for
2737              function pointer references.  */
2738           unsigned int sym_type;
2739           if (h)
2740             sym_type = h->type;
2741           else
2742             sym_type = ELF_ST_TYPE (sym->st_info);
2743           if (sym_type == STT_FUNC)
2744             spu_hash_table (info)->non_ovly_stub += 1;
2745           continue;
2746         }
2747
2748       if (h)
2749         val = h->root.u.def.value;
2750       else
2751         val = sym->st_value;
2752       val += irela->r_addend;
2753
2754       if (!call_tree)
2755         {
2756           struct function_info *fun;
2757
2758           if (irela->r_addend != 0)
2759             {
2760               Elf_Internal_Sym *fake = bfd_zmalloc (sizeof (*fake));
2761               if (fake == NULL)
2762                 return FALSE;
2763               fake->st_value = val;
2764               fake->st_shndx
2765                 = _bfd_elf_section_from_bfd_section (sym_sec->owner, sym_sec);
2766               sym = fake;
2767             }
2768           if (sym)
2769             fun = maybe_insert_function (sym_sec, sym, FALSE, is_call);
2770           else
2771             fun = maybe_insert_function (sym_sec, h, TRUE, is_call);
2772           if (fun == NULL)
2773             return FALSE;
2774           if (irela->r_addend != 0
2775               && fun->u.sym != sym)
2776             free (sym);
2777           continue;
2778         }
2779
2780       caller = find_function (sec, irela->r_offset, info);
2781       if (caller == NULL)
2782         return FALSE;
2783       callee = bfd_malloc (sizeof *callee);
2784       if (callee == NULL)
2785         return FALSE;
2786
2787       callee->fun = find_function (sym_sec, val, info);
2788       if (callee->fun == NULL)
2789         return FALSE;
2790       callee->is_tail = !is_call;
2791       callee->is_pasted = FALSE;
2792       callee->priority = priority;
2793       callee->count = 0;
2794       if (callee->fun->last_caller != sec)
2795         {
2796           callee->fun->last_caller = sec;
2797           callee->fun->call_count += 1;
2798         }
2799       if (!insert_callee (caller, callee))
2800         free (callee);
2801       else if (!is_call
2802                && !callee->fun->is_func
2803                && callee->fun->stack == 0)
2804         {
2805           /* This is either a tail call or a branch from one part of
2806              the function to another, ie. hot/cold section.  If the
2807              destination has been called by some other function then
2808              it is a separate function.  We also assume that functions
2809              are not split across input files.  */
2810           if (sec->owner != sym_sec->owner)
2811             {
2812               callee->fun->start = NULL;
2813               callee->fun->is_func = TRUE;
2814             }
2815           else if (callee->fun->start == NULL)
2816             {
2817               struct function_info *caller_start = caller;
2818               while (caller_start->start)
2819                 caller_start = caller_start->start;
2820
2821               if (caller_start != callee->fun)
2822                 callee->fun->start = caller_start;
2823             }
2824           else
2825             {
2826               struct function_info *callee_start;
2827               struct function_info *caller_start;
2828               callee_start = callee->fun;
2829               while (callee_start->start)
2830                 callee_start = callee_start->start;
2831               caller_start = caller;
2832               while (caller_start->start)
2833                 caller_start = caller_start->start;
2834               if (caller_start != callee_start)
2835                 {
2836                   callee->fun->start = NULL;
2837                   callee->fun->is_func = TRUE;
2838                 }
2839             }
2840         }
2841     }
2842
2843   return TRUE;
2844 }
2845
2846 /* Handle something like .init or .fini, which has a piece of a function.
2847    These sections are pasted together to form a single function.  */
2848
2849 static bfd_boolean
2850 pasted_function (asection *sec)
2851 {
2852   struct bfd_link_order *l;
2853   struct _spu_elf_section_data *sec_data;
2854   struct spu_elf_stack_info *sinfo;
2855   Elf_Internal_Sym *fake;
2856   struct function_info *fun, *fun_start;
2857
2858   fake = bfd_zmalloc (sizeof (*fake));
2859   if (fake == NULL)
2860     return FALSE;
2861   fake->st_value = 0;
2862   fake->st_size = sec->size;
2863   fake->st_shndx
2864     = _bfd_elf_section_from_bfd_section (sec->owner, sec);
2865   fun = maybe_insert_function (sec, fake, FALSE, FALSE);
2866   if (!fun)
2867     return FALSE;
2868
2869   /* Find a function immediately preceding this section.  */
2870   fun_start = NULL;
2871   for (l = sec->output_section->map_head.link_order; l != NULL; l = l->next)
2872     {
2873       if (l->u.indirect.section == sec)
2874         {
2875           if (fun_start != NULL)
2876             {
2877               struct call_info *callee = bfd_malloc (sizeof *callee);
2878               if (callee == NULL)
2879                 return FALSE;
2880
2881               fun->start = fun_start;
2882               callee->fun = fun;
2883               callee->is_tail = TRUE;
2884               callee->is_pasted = TRUE;
2885               callee->count = 0;
2886               if (!insert_callee (fun_start, callee))
2887                 free (callee);
2888               return TRUE;
2889             }
2890           break;
2891         }
2892       if (l->type == bfd_indirect_link_order
2893           && (sec_data = spu_elf_section_data (l->u.indirect.section)) != NULL
2894           && (sinfo = sec_data->u.i.stack_info) != NULL
2895           && sinfo->num_fun != 0)
2896         fun_start = &sinfo->fun[sinfo->num_fun - 1];
2897     }
2898
2899   /* Don't return an error if we did not find a function preceding this
2900      section.  The section may have incorrect flags.  */
2901   return TRUE;
2902 }
2903
2904 /* Map address ranges in code sections to functions.  */
2905
2906 static bfd_boolean
2907 discover_functions (struct bfd_link_info *info)
2908 {
2909   bfd *ibfd;
2910   int bfd_idx;
2911   Elf_Internal_Sym ***psym_arr;
2912   asection ***sec_arr;
2913   bfd_boolean gaps = FALSE;
2914
2915   bfd_idx = 0;
2916   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2917     bfd_idx++;
2918
2919   psym_arr = bfd_zmalloc (bfd_idx * sizeof (*psym_arr));
2920   if (psym_arr == NULL)
2921     return FALSE;
2922   sec_arr = bfd_zmalloc (bfd_idx * sizeof (*sec_arr));
2923   if (sec_arr == NULL)
2924     return FALSE;
2925
2926   for (ibfd = info->input_bfds, bfd_idx = 0;
2927        ibfd != NULL;
2928        ibfd = ibfd->link_next, bfd_idx++)
2929     {
2930       extern const bfd_target bfd_elf32_spu_vec;
2931       Elf_Internal_Shdr *symtab_hdr;
2932       asection *sec;
2933       size_t symcount;
2934       Elf_Internal_Sym *syms, *sy, **psyms, **psy;
2935       asection **psecs, **p;
2936
2937       if (ibfd->xvec != &bfd_elf32_spu_vec)
2938         continue;
2939
2940       /* Read all the symbols.  */
2941       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2942       symcount = symtab_hdr->sh_size / symtab_hdr->sh_entsize;
2943       if (symcount == 0)
2944         {
2945           if (!gaps)
2946             for (sec = ibfd->sections; sec != NULL && !gaps; sec = sec->next)
2947               if (interesting_section (sec))
2948                 {
2949                   gaps = TRUE;
2950                   break;
2951                 }
2952           continue;
2953         }
2954
2955       if (symtab_hdr->contents != NULL)
2956         {
2957           /* Don't use cached symbols since the generic ELF linker
2958              code only reads local symbols, and we need globals too.  */
2959           free (symtab_hdr->contents);
2960           symtab_hdr->contents = NULL;
2961         }
2962       syms = bfd_elf_get_elf_syms (ibfd, symtab_hdr, symcount, 0,
2963                                    NULL, NULL, NULL);
2964       symtab_hdr->contents = (void *) syms;
2965       if (syms == NULL)
2966         return FALSE;
2967
2968       /* Select defined function symbols that are going to be output.  */
2969       psyms = bfd_malloc ((symcount + 1) * sizeof (*psyms));
2970       if (psyms == NULL)
2971         return FALSE;
2972       psym_arr[bfd_idx] = psyms;
2973       psecs = bfd_malloc (symcount * sizeof (*psecs));
2974       if (psecs == NULL)
2975         return FALSE;
2976       sec_arr[bfd_idx] = psecs;
2977       for (psy = psyms, p = psecs, sy = syms; sy < syms + symcount; ++p, ++sy)
2978         if (ELF_ST_TYPE (sy->st_info) == STT_NOTYPE
2979             || ELF_ST_TYPE (sy->st_info) == STT_FUNC)
2980           {
2981             asection *s;
2982
2983             *p = s = bfd_section_from_elf_index (ibfd, sy->st_shndx);
2984             if (s != NULL && interesting_section (s))
2985               *psy++ = sy;
2986           }
2987       symcount = psy - psyms;
2988       *psy = NULL;
2989
2990       /* Sort them by section and offset within section.  */
2991       sort_syms_syms = syms;
2992       sort_syms_psecs = psecs;
2993       qsort (psyms, symcount, sizeof (*psyms), sort_syms);
2994
2995       /* Now inspect the function symbols.  */
2996       for (psy = psyms; psy < psyms + symcount; )
2997         {
2998           asection *s = psecs[*psy - syms];
2999           Elf_Internal_Sym **psy2;
3000
3001           for (psy2 = psy; ++psy2 < psyms + symcount; )
3002             if (psecs[*psy2 - syms] != s)
3003               break;
3004
3005           if (!alloc_stack_info (s, psy2 - psy))
3006             return FALSE;
3007           psy = psy2;
3008         }
3009
3010       /* First install info about properly typed and sized functions.
3011          In an ideal world this will cover all code sections, except
3012          when partitioning functions into hot and cold sections,
3013          and the horrible pasted together .init and .fini functions.  */
3014       for (psy = psyms; psy < psyms + symcount; ++psy)
3015         {
3016           sy = *psy;
3017           if (ELF_ST_TYPE (sy->st_info) == STT_FUNC)
3018             {
3019               asection *s = psecs[sy - syms];
3020               if (!maybe_insert_function (s, sy, FALSE, TRUE))
3021                 return FALSE;
3022             }
3023         }
3024
3025       for (sec = ibfd->sections; sec != NULL && !gaps; sec = sec->next)
3026         if (interesting_section (sec))
3027           gaps |= check_function_ranges (sec, info);
3028     }
3029
3030   if (gaps)
3031     {
3032       /* See if we can discover more function symbols by looking at
3033          relocations.  */
3034       for (ibfd = info->input_bfds, bfd_idx = 0;
3035            ibfd != NULL;
3036            ibfd = ibfd->link_next, bfd_idx++)
3037         {
3038           asection *sec;
3039
3040           if (psym_arr[bfd_idx] == NULL)
3041             continue;
3042
3043           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
3044             if (!mark_functions_via_relocs (sec, info, FALSE))
3045               return FALSE;
3046         }
3047
3048       for (ibfd = info->input_bfds, bfd_idx = 0;
3049            ibfd != NULL;
3050            ibfd = ibfd->link_next, bfd_idx++)
3051         {
3052           Elf_Internal_Shdr *symtab_hdr;
3053           asection *sec;
3054           Elf_Internal_Sym *syms, *sy, **psyms, **psy;
3055           asection **psecs;
3056
3057           if ((psyms = psym_arr[bfd_idx]) == NULL)
3058             continue;
3059
3060           psecs = sec_arr[bfd_idx];
3061
3062           symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
3063           syms = (Elf_Internal_Sym *) symtab_hdr->contents;
3064
3065           gaps = FALSE;
3066           for (sec = ibfd->sections; sec != NULL && !gaps; sec = sec->next)
3067             if (interesting_section (sec))
3068               gaps |= check_function_ranges (sec, info);
3069           if (!gaps)
3070             continue;
3071
3072           /* Finally, install all globals.  */
3073           for (psy = psyms; (sy = *psy) != NULL; ++psy)
3074             {
3075               asection *s;
3076
3077               s = psecs[sy - syms];
3078
3079               /* Global syms might be improperly typed functions.  */
3080               if (ELF_ST_TYPE (sy->st_info) != STT_FUNC
3081                   && ELF_ST_BIND (sy->st_info) == STB_GLOBAL)
3082                 {
3083                   if (!maybe_insert_function (s, sy, FALSE, FALSE))
3084                     return FALSE;
3085                 }
3086             }
3087         }
3088
3089       for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
3090         {
3091           extern const bfd_target bfd_elf32_spu_vec;
3092           asection *sec;
3093
3094           if (ibfd->xvec != &bfd_elf32_spu_vec)
3095             continue;
3096
3097           /* Some of the symbols we've installed as marking the
3098              beginning of functions may have a size of zero.  Extend
3099              the range of such functions to the beginning of the
3100              next symbol of interest.  */
3101           for (sec = ibfd->sections; sec != NULL; sec = sec->next)
3102             if (interesting_section (sec))
3103               {
3104                 struct _spu_elf_section_data *sec_data;
3105                 struct spu_elf_stack_info *sinfo;
3106
3107                 sec_data = spu_elf_section_data (sec);
3108                 sinfo = sec_data->u.i.stack_info;
3109                 if (sinfo != NULL && sinfo->num_fun != 0)
3110                   {
3111                     int fun_idx;
3112                     bfd_vma hi = sec->size;
3113
3114                     for (fun_idx = sinfo->num_fun; --fun_idx >= 0; )
3115                       {
3116                         sinfo->fun[fun_idx].hi = hi;
3117                         hi = sinfo->fun[fun_idx].lo;
3118                       }
3119
3120                     sinfo->fun[0].lo = 0;
3121                   }
3122                 /* No symbols in this section.  Must be .init or .fini
3123                    or something similar.  */
3124                 else if (!pasted_function (sec))
3125                   return FALSE;
3126               }
3127         }
3128     }
3129
3130   for (ibfd = info->input_bfds, bfd_idx = 0;
3131        ibfd != NULL;
3132        ibfd = ibfd->link_next, bfd_idx++)
3133     {
3134       if (psym_arr[bfd_idx] == NULL)
3135         continue;
3136
3137       free (psym_arr[bfd_idx]);
3138       free (sec_arr[bfd_idx]);
3139     }
3140
3141   free (psym_arr);
3142   free (sec_arr);
3143
3144   return TRUE;
3145 }
3146
3147 /* Iterate over all function_info we have collected, calling DOIT on
3148    each node if ROOT_ONLY is false.  Only call DOIT on root nodes
3149    if ROOT_ONLY.  */
3150
3151 static bfd_boolean
3152 for_each_node (bfd_boolean (*doit) (struct function_info *,
3153                                     struct bfd_link_info *,
3154                                     void *),
3155                struct bfd_link_info *info,
3156                void *param,
3157                int root_only)
3158 {
3159   bfd *ibfd;
3160
3161   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
3162     {
3163       extern const bfd_target bfd_elf32_spu_vec;
3164       asection *sec;
3165
3166       if (ibfd->xvec != &bfd_elf32_spu_vec)
3167         continue;
3168
3169       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
3170         {
3171           struct _spu_elf_section_data *sec_data;
3172           struct spu_elf_stack_info *sinfo;
3173
3174           if ((sec_data = spu_elf_section_data (sec)) != NULL
3175               && (sinfo = sec_data->u.i.stack_info) != NULL)
3176             {
3177               int i;
3178               for (i = 0; i < sinfo->num_fun; ++i)
3179                 if (!root_only || !sinfo->fun[i].non_root)
3180                   if (!doit (&sinfo->fun[i], info, param))
3181                     return FALSE;
3182             }
3183         }
3184     }
3185   return TRUE;
3186 }
3187
3188 /* Transfer call info attached to struct function_info entries for
3189    all of a given function's sections to the first entry.  */
3190
3191 static bfd_boolean
3192 transfer_calls (struct function_info *fun,
3193                 struct bfd_link_info *info ATTRIBUTE_UNUSED,
3194                 void *param ATTRIBUTE_UNUSED)
3195 {
3196   struct function_info *start = fun->start;
3197
3198   if (start != NULL)
3199     {
3200       struct call_info *call, *call_next;
3201
3202       while (start->start != NULL)
3203         start = start->start;
3204       for (call = fun->call_list; call != NULL; call = call_next)
3205         {
3206           call_next = call->next;
3207           if (!insert_callee (start, call))
3208             free (call);
3209         }
3210       fun->call_list = NULL;
3211     }
3212   return TRUE;
3213 }
3214
3215 /* Mark nodes in the call graph that are called by some other node.  */
3216
3217 static bfd_boolean
3218 mark_non_root (struct function_info *fun,
3219                struct bfd_link_info *info ATTRIBUTE_UNUSED,
3220                void *param ATTRIBUTE_UNUSED)
3221 {
3222   struct call_info *call;
3223
3224   if (fun->visit1)
3225     return TRUE;
3226   fun->visit1 = TRUE;
3227   for (call = fun->call_list; call; call = call->next)
3228     {
3229       call->fun->non_root = TRUE;
3230       mark_non_root (call->fun, 0, 0);
3231     }
3232   return TRUE;
3233 }
3234
3235 /* Remove cycles from the call graph.  Set depth of nodes.  */
3236
3237 static bfd_boolean
3238 remove_cycles (struct function_info *fun,
3239                struct bfd_link_info *info,
3240                void *param)
3241 {
3242   struct call_info **callp, *call;
3243   unsigned int depth = *(unsigned int *) param;
3244   unsigned int max_depth = depth;
3245
3246   fun->depth = depth;
3247   fun->visit2 = TRUE;
3248   fun->marking = TRUE;
3249
3250   callp = &fun->call_list;
3251   while ((call = *callp) != NULL)
3252     {
3253       call->max_depth = depth + !call->is_pasted;
3254       if (!call->fun->visit2)
3255         {
3256           if (!remove_cycles (call->fun, info, &call->max_depth))
3257             return FALSE;
3258           if (max_depth < call->max_depth)
3259             max_depth = call->max_depth;
3260         }
3261       else if (call->fun->marking)
3262         {
3263           struct spu_link_hash_table *htab = spu_hash_table (info);
3264
3265           if (!htab->params->auto_overlay
3266               && htab->params->stack_analysis)
3267             {
3268               const char *f1 = func_name (fun);
3269               const char *f2 = func_name (call->fun);
3270
3271               info->callbacks->info (_("Stack analysis will ignore the call "
3272                                        "from %s to %s\n"),
3273                                      f1, f2);
3274             }
3275           *callp = call->next;
3276           free (call);
3277           continue;
3278         }
3279       callp = &call->next;
3280     }
3281   fun->marking = FALSE;
3282   *(unsigned int *) param = max_depth;
3283   return TRUE;
3284 }
3285
3286 /* Check that we actually visited all nodes in remove_cycles.  If we
3287    didn't, then there is some cycle in the call graph not attached to
3288    any root node.  Arbitrarily choose a node in the cycle as a new
3289    root and break the cycle.  */
3290
3291 static bfd_boolean
3292 mark_detached_root (struct function_info *fun,
3293                     struct bfd_link_info *info,
3294                     void *param)
3295 {
3296   if (fun->visit2)
3297     return TRUE;
3298   fun->non_root = FALSE;
3299   *(unsigned int *) param = 0;
3300   return remove_cycles (fun, info, param);
3301 }
3302
3303 /* Populate call_list for each function.  */
3304
3305 static bfd_boolean
3306 build_call_tree (struct bfd_link_info *info)
3307 {
3308   bfd *ibfd;
3309   unsigned int depth;
3310
3311   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
3312     {
3313       extern const bfd_target bfd_elf32_spu_vec;
3314       asection *sec;
3315
3316       if (ibfd->xvec != &bfd_elf32_spu_vec)
3317         continue;
3318
3319       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
3320         if (!mark_functions_via_relocs (sec, info, TRUE))
3321           return FALSE;
3322     }
3323
3324   /* Transfer call info from hot/cold section part of function
3325      to main entry.  */
3326   if (!spu_hash_table (info)->params->auto_overlay
3327       && !for_each_node (transfer_calls, info, 0, FALSE))
3328     return FALSE;
3329
3330   /* Find the call graph root(s).  */
3331   if (!for_each_node (mark_non_root, info, 0, FALSE))
3332     return FALSE;
3333
3334   /* Remove cycles from the call graph.  We start from the root node(s)
3335      so that we break cycles in a reasonable place.  */
3336   depth = 0;
3337   if (!for_each_node (remove_cycles, info, &depth, TRUE))
3338     return FALSE;
3339
3340   return for_each_node (mark_detached_root, info, &depth, FALSE);
3341 }
3342
3343 /* qsort predicate to sort calls by priority, max_depth then count.  */
3344
3345 static int
3346 sort_calls (const void *a, const void *b)
3347 {
3348   struct call_info *const *c1 = a;
3349   struct call_info *const *c2 = b;
3350   int delta;
3351
3352   delta = (*c2)->priority - (*c1)->priority;
3353   if (delta != 0)
3354     return delta;
3355
3356   delta = (*c2)->max_depth - (*c1)->max_depth;
3357   if (delta != 0)
3358     return delta;
3359
3360   delta = (*c2)->count - (*c1)->count;
3361   if (delta != 0)
3362     return delta;
3363
3364   return (char *) c1 - (char *) c2;
3365 }
3366
3367 struct _mos_param {
3368   unsigned int max_overlay_size;
3369 };
3370
3371 /* Set linker_mark and gc_mark on any sections that we will put in
3372    overlays.  These flags are used by the generic ELF linker, but we
3373    won't be continuing on to bfd_elf_final_link so it is OK to use
3374    them.  linker_mark is clear before we get here.  Set segment_mark
3375    on sections that are part of a pasted function (excluding the last
3376    section).
3377
3378    Set up function rodata section if --overlay-rodata.  We don't
3379    currently include merged string constant rodata sections since
3380
3381    Sort the call graph so that the deepest nodes will be visited
3382    first.  */
3383
3384 static bfd_boolean
3385 mark_overlay_section (struct function_info *fun,
3386                       struct bfd_link_info *info,
3387                       void *param)
3388 {
3389   struct call_info *call;
3390   unsigned int count;
3391   struct _mos_param *mos_param = param;
3392   struct spu_link_hash_table *htab = spu_hash_table (info);
3393
3394   if (fun->visit4)
3395     return TRUE;
3396
3397   fun->visit4 = TRUE;
3398   if (!fun->sec->linker_mark
3399       && (htab->params->ovly_flavour != ovly_soft_icache
3400           || htab->params->non_ia_text
3401           || strncmp (fun->sec->name, ".text.ia.", 9) == 0
3402           || strcmp (fun->sec->name, ".init") == 0
3403           || strcmp (fun->sec->name, ".fini") == 0))
3404     {
3405       unsigned int size;
3406
3407       fun->sec->linker_mark = 1;
3408       fun->sec->gc_mark = 1;
3409       fun->sec->segment_mark = 0;
3410       /* Ensure SEC_CODE is set on this text section (it ought to
3411          be!), and SEC_CODE is clear on rodata sections.  We use
3412          this flag to differentiate the two overlay section types.  */
3413       fun->sec->flags |= SEC_CODE;
3414
3415       size = fun->sec->size;
3416       if (htab->params->auto_overlay & OVERLAY_RODATA)
3417         {
3418           char *name = NULL;
3419
3420           /* Find the rodata section corresponding to this function's
3421              text section.  */
3422           if (strcmp (fun->sec->name, ".text") == 0)
3423             {
3424               name = bfd_malloc (sizeof (".rodata"));
3425               if (name == NULL)
3426                 return FALSE;
3427               memcpy (name, ".rodata", sizeof (".rodata"));
3428             }
3429           else if (strncmp (fun->sec->name, ".text.", 6) == 0)
3430             {
3431               size_t len = strlen (fun->sec->name);
3432               name = bfd_malloc (len + 3);
3433               if (name == NULL)
3434                 return FALSE;
3435               memcpy (name, ".rodata", sizeof (".rodata"));
3436               memcpy (name + 7, fun->sec->name + 5, len - 4);
3437             }
3438           else if (strncmp (fun->sec->name, ".gnu.linkonce.t.", 16) == 0)
3439             {
3440               size_t len = strlen (fun->sec->name) + 1;
3441               name = bfd_malloc (len);
3442               if (name == NULL)
3443                 return FALSE;
3444               memcpy (name, fun->sec->name, len);
3445               name[14] = 'r';
3446             }
3447
3448           if (name != NULL)
3449             {
3450               asection *rodata = NULL;
3451               asection *group_sec = elf_section_data (fun->sec)->next_in_group;
3452               if (group_sec == NULL)
3453                 rodata = bfd_get_section_by_name (fun->sec->owner, name);
3454               else
3455                 while (group_sec != NULL && group_sec != fun->sec)
3456                   {
3457                     if (strcmp (group_sec->name, name) == 0)
3458                       {
3459                         rodata = group_sec;
3460                         break;
3461                       }
3462                     group_sec = elf_section_data (group_sec)->next_in_group;
3463                   }
3464               fun->rodata = rodata;
3465               if (fun->rodata)
3466                 {
3467                   size += fun->rodata->size;
3468                   if (htab->params->line_size != 0
3469                       && size > htab->params->line_size)
3470                     {
3471                       size -= fun->rodata->size;
3472                       fun->rodata = NULL;
3473                     }
3474                   else
3475                     {
3476                       fun->rodata->linker_mark = 1;
3477                       fun->rodata->gc_mark = 1;
3478                       fun->rodata->flags &= ~SEC_CODE;
3479                     }
3480                 }
3481               free (name);
3482             }
3483         }
3484       if (mos_param->max_overlay_size < size)
3485         mos_param->max_overlay_size = size;
3486     }
3487
3488   for (count = 0, call = fun->call_list; call != NULL; call = call->next)
3489     count += 1;
3490
3491   if (count > 1)
3492     {
3493       struct call_info **calls = bfd_malloc (count * sizeof (*calls));
3494       if (calls == NULL)
3495         return FALSE;
3496
3497       for (count = 0, call = fun->call_list; call != NULL; call = call->next)
3498         calls[count++] = call;
3499
3500       qsort (calls, count, sizeof (*calls), sort_calls);
3501
3502       fun->call_list = NULL;
3503       while (count != 0)
3504         {
3505           --count;
3506           calls[count]->next = fun->call_list;
3507           fun->call_list = calls[count];
3508         }
3509       free (calls);
3510     }
3511
3512   for (call = fun->call_list; call != NULL; call = call->next)
3513     {
3514       if (call->is_pasted)
3515         {
3516           /* There can only be one is_pasted call per function_info.  */
3517           BFD_ASSERT (!fun->sec->segment_mark);
3518           fun->sec->segment_mark = 1;
3519         }
3520       if (!mark_overlay_section (call->fun, info, param))
3521         return FALSE;
3522     }
3523
3524   /* Don't put entry code into an overlay.  The overlay manager needs
3525      a stack!  Also, don't mark .ovl.init as an overlay.  */
3526   if (fun->lo + fun->sec->output_offset + fun->sec->output_section->vma
3527       == info->output_bfd->start_address
3528       || strncmp (fun->sec->output_section->name, ".ovl.init", 9) == 0)
3529     {
3530       fun->sec->linker_mark = 0;
3531       if (fun->rodata != NULL)
3532         fun->rodata->linker_mark = 0;
3533     }
3534   return TRUE;
3535 }
3536
3537 /* If non-zero then unmark functions called from those within sections
3538    that we need to unmark.  Unfortunately this isn't reliable since the
3539    call graph cannot know the destination of function pointer calls.  */
3540 #define RECURSE_UNMARK 0
3541
3542 struct _uos_param {
3543   asection *exclude_input_section;
3544   asection *exclude_output_section;
3545   unsigned long clearing;
3546 };
3547
3548 /* Undo some of mark_overlay_section's work.  */
3549
3550 static bfd_boolean
3551 unmark_overlay_section (struct function_info *fun,
3552                         struct bfd_link_info *info,
3553                         void *param)
3554 {
3555   struct call_info *call;
3556   struct _uos_param *uos_param = param;
3557   unsigned int excluded = 0;
3558
3559   if (fun->visit5)
3560     return TRUE;
3561
3562   fun->visit5 = TRUE;
3563
3564   excluded = 0;
3565   if (fun->sec == uos_param->exclude_input_section
3566       || fun->sec->output_section == uos_param->exclude_output_section)
3567     excluded = 1;
3568
3569   if (RECURSE_UNMARK)
3570     uos_param->clearing += excluded;
3571
3572   if (RECURSE_UNMARK ? uos_param->clearing : excluded)
3573     {
3574       fun->sec->linker_mark = 0;
3575       if (fun->rodata)
3576         fun->rodata->linker_mark = 0;
3577     }
3578
3579   for (call = fun->call_list; call != NULL; call = call->next)
3580     if (!unmark_overlay_section (call->fun, info, param))
3581       return FALSE;
3582
3583   if (RECURSE_UNMARK)
3584     uos_param->clearing -= excluded;
3585   return TRUE;
3586 }
3587
3588 struct _cl_param {
3589   unsigned int lib_size;
3590   asection **lib_sections;
3591 };
3592
3593 /* Add sections we have marked as belonging to overlays to an array
3594    for consideration as non-overlay sections.  The array consist of
3595    pairs of sections, (text,rodata), for functions in the call graph.  */
3596
3597 static bfd_boolean
3598 collect_lib_sections (struct function_info *fun,
3599                       struct bfd_link_info *info,
3600                       void *param)
3601 {
3602   struct _cl_param *lib_param = param;
3603   struct call_info *call;
3604   unsigned int size;
3605
3606   if (fun->visit6)
3607     return TRUE;
3608
3609   fun->visit6 = TRUE;
3610   if (!fun->sec->linker_mark || !fun->sec->gc_mark || fun->sec->segment_mark)
3611     return TRUE;
3612
3613   size = fun->sec->size;
3614   if (fun->rodata)
3615     size += fun->rodata->size;
3616
3617   if (size <= lib_param->lib_size)
3618     {
3619       *lib_param->lib_sections++ = fun->sec;
3620       fun->sec->gc_mark = 0;
3621       if (fun->rodata && fun->rodata->linker_mark && fun->rodata->gc_mark)
3622         {
3623           *lib_param->lib_sections++ = fun->rodata;
3624           fun->rodata->gc_mark = 0;
3625         }
3626       else
3627         *lib_param->lib_sections++ = NULL;
3628     }
3629
3630   for (call = fun->call_list; call != NULL; call = call->next)
3631     collect_lib_sections (call->fun, info, param);
3632
3633   return TRUE;
3634 }
3635
3636 /* qsort predicate to sort sections by call count.  */
3637
3638 static int
3639 sort_lib (const void *a, const void *b)
3640 {
3641   asection *const *s1 = a;
3642   asection *const *s2 = b;
3643   struct _spu_elf_section_data *sec_data;
3644   struct spu_elf_stack_info *sinfo;
3645   int delta;
3646
3647   delta = 0;
3648   if ((sec_data = spu_elf_section_data (*s1)) != NULL
3649       && (sinfo = sec_data->u.i.stack_info) != NULL)
3650     {
3651       int i;
3652       for (i = 0; i < sinfo->num_fun; ++i)
3653         delta -= sinfo->fun[i].call_count;
3654     }
3655
3656   if ((sec_data = spu_elf_section_data (*s2)) != NULL
3657       && (sinfo = sec_data->u.i.stack_info) != NULL)
3658     {
3659       int i;
3660       for (i = 0; i < sinfo->num_fun; ++i)
3661         delta += sinfo->fun[i].call_count;
3662     }
3663
3664   if (delta != 0)
3665     return delta;
3666
3667   return s1 - s2;
3668 }
3669
3670 /* Remove some sections from those marked to be in overlays.  Choose
3671    those that are called from many places, likely library functions.  */
3672
3673 static unsigned int
3674 auto_ovl_lib_functions (struct bfd_link_info *info, unsigned int lib_size)
3675 {
3676   bfd *ibfd;
3677   asection **lib_sections;
3678   unsigned int i, lib_count;
3679   struct _cl_param collect_lib_param;
3680   struct function_info dummy_caller;
3681   struct spu_link_hash_table *htab;
3682
3683   memset (&dummy_caller, 0, sizeof (dummy_caller));
3684   lib_count = 0;
3685   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
3686     {
3687       extern const bfd_target bfd_elf32_spu_vec;
3688       asection *sec;
3689
3690       if (ibfd->xvec != &bfd_elf32_spu_vec)
3691         continue;
3692
3693       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
3694         if (sec->linker_mark
3695             && sec->size < lib_size
3696             && (sec->flags & SEC_CODE) != 0)
3697           lib_count += 1;
3698     }
3699   lib_sections = bfd_malloc (lib_count * 2 * sizeof (*lib_sections));
3700   if (lib_sections == NULL)
3701     return (unsigned int) -1;
3702   collect_lib_param.lib_size = lib_size;
3703   collect_lib_param.lib_sections = lib_sections;
3704   if (!for_each_node (collect_lib_sections, info, &collect_lib_param,
3705                       TRUE))
3706     return (unsigned int) -1;
3707   lib_count = (collect_lib_param.lib_sections - lib_sections) / 2;
3708
3709   /* Sort sections so that those with the most calls are first.  */
3710   if (lib_count > 1)
3711     qsort (lib_sections, lib_count, 2 * sizeof (*lib_sections), sort_lib);
3712
3713   htab = spu_hash_table (info);
3714   for (i = 0; i < lib_count; i++)
3715     {
3716       unsigned int tmp, stub_size;
3717       asection *sec;
3718       struct _spu_elf_section_data *sec_data;
3719       struct spu_elf_stack_info *sinfo;
3720
3721       sec = lib_sections[2 * i];
3722       /* If this section is OK, its size must be less than lib_size.  */
3723       tmp = sec->size;
3724       /* If it has a rodata section, then add that too.  */
3725       if (lib_sections[2 * i + 1])
3726         tmp += lib_sections[2 * i + 1]->size;
3727       /* Add any new overlay call stubs needed by the section.  */
3728       stub_size = 0;
3729       if (tmp < lib_size
3730           && (sec_data = spu_elf_section_data (sec)) != NULL
3731           && (sinfo = sec_data->u.i.stack_info) != NULL)
3732         {
3733           int k;
3734           struct call_info *call;
3735
3736           for (k = 0; k < sinfo->num_fun; ++k)
3737             for (call = sinfo->fun[k].call_list; call; call = call->next)
3738               if (call->fun->sec->linker_mark)
3739                 {
3740                   struct call_info *p;
3741                   for (p = dummy_caller.call_list; p; p = p->next)
3742                     if (p->fun == call->fun)
3743                       break;
3744                   if (!p)
3745                     stub_size += ovl_stub_size (htab->params);
3746                 }
3747         }
3748       if (tmp + stub_size < lib_size)
3749         {
3750           struct call_info **pp, *p;
3751
3752           /* This section fits.  Mark it as non-overlay.  */
3753           lib_sections[2 * i]->linker_mark = 0;
3754           if (lib_sections[2 * i + 1])
3755             lib_sections[2 * i + 1]->linker_mark = 0;
3756           lib_size -= tmp + stub_size;
3757           /* Call stubs to the section we just added are no longer
3758              needed.  */
3759           pp = &dummy_caller.call_list;
3760           while ((p = *pp) != NULL)
3761             if (!p->fun->sec->linker_mark)
3762               {
3763                 lib_size += ovl_stub_size (htab->params);
3764                 *pp = p->next;
3765                 free (p);
3766               }
3767             else
3768               pp = &p->next;
3769           /* Add new call stubs to dummy_caller.  */
3770           if ((sec_data = spu_elf_section_data (sec)) != NULL
3771               && (sinfo = sec_data->u.i.stack_info) != NULL)
3772             {
3773               int k;
3774               struct call_info *call;
3775
3776               for (k = 0; k < sinfo->num_fun; ++k)
3777                 for (call = sinfo->fun[k].call_list;
3778                      call;
3779                      call = call->next)
3780                   if (call->fun->sec->linker_mark)
3781                     {
3782                       struct call_info *callee;
3783                       callee = bfd_malloc (sizeof (*callee));
3784                       if (callee == NULL)
3785                         return (unsigned int) -1;
3786                       *callee = *call;
3787                       if (!insert_callee (&dummy_caller, callee))
3788                         free (callee);
3789                     }
3790             }
3791         }
3792     }
3793   while (dummy_caller.call_list != NULL)
3794     {
3795       struct call_info *call = dummy_caller.call_list;
3796       dummy_caller.call_list = call->next;
3797       free (call);
3798     }
3799   for (i = 0; i < 2 * lib_count; i++)
3800     if (lib_sections[i])
3801       lib_sections[i]->gc_mark = 1;
3802   free (lib_sections);
3803   return lib_size;
3804 }
3805
3806 /* Build an array of overlay sections.  The deepest node's section is
3807    added first, then its parent node's section, then everything called
3808    from the parent section.  The idea being to group sections to
3809    minimise calls between different overlays.  */
3810
3811 static bfd_boolean
3812 collect_overlays (struct function_info *fun,
3813                   struct bfd_link_info *info,
3814                   void *param)
3815 {
3816   struct call_info *call;
3817   bfd_boolean added_fun;
3818   asection ***ovly_sections = param;
3819
3820   if (fun->visit7)
3821     return TRUE;
3822
3823   fun->visit7 = TRUE;
3824   for (call = fun->call_list; call != NULL; call = call->next)
3825     if (!call->is_pasted)
3826       {
3827         if (!collect_overlays (call->fun, info, ovly_sections))
3828           return FALSE;
3829         break;
3830       }
3831
3832   added_fun = FALSE;
3833   if (fun->sec->linker_mark && fun->sec->gc_mark)
3834     {
3835       fun->sec->gc_mark = 0;
3836       *(*ovly_sections)++ = fun->sec;
3837       if (fun->rodata && fun->rodata->linker_mark && fun->rodata->gc_mark)
3838         {
3839           fun->rodata->gc_mark = 0;
3840           *(*ovly_sections)++ = fun->rodata;
3841         }
3842       else
3843         *(*ovly_sections)++ = NULL;
3844       added_fun = TRUE;
3845
3846       /* Pasted sections must stay with the first section.  We don't
3847          put pasted sections in the array, just the first section.
3848          Mark subsequent sections as already considered.  */
3849       if (fun->sec->segment_mark)
3850         {
3851           struct function_info *call_fun = fun;
3852           do
3853             {
3854               for (call = call_fun->call_list; call != NULL; call = call->next)
3855                 if (call->is_pasted)
3856                   {
3857                     call_fun = call->fun;
3858                     call_fun->sec->gc_mark = 0;
3859                     if (call_fun->rodata)
3860                       call_fun->rodata->gc_mark = 0;
3861                     break;
3862                   }
3863               if (call == NULL)
3864                 abort ();
3865             }
3866           while (call_fun->sec->segment_mark);
3867         }
3868     }
3869
3870   for (call = fun->call_list; call != NULL; call = call->next)
3871     if (!collect_overlays (call->fun, info, ovly_sections))
3872       return FALSE;
3873
3874   if (added_fun)
3875     {
3876       struct _spu_elf_section_data *sec_data;
3877       struct spu_elf_stack_info *sinfo;
3878
3879       if ((sec_data = spu_elf_section_data (fun->sec)) != NULL
3880           && (sinfo = sec_data->u.i.stack_info) != NULL)
3881         {
3882           int i;
3883           for (i = 0; i < sinfo->num_fun; ++i)
3884             if (!collect_overlays (&sinfo->fun[i], info, ovly_sections))
3885               return FALSE;
3886         }
3887     }
3888
3889   return TRUE;
3890 }
3891
3892 struct _sum_stack_param {
3893   size_t cum_stack;
3894   size_t overall_stack;
3895   bfd_boolean emit_stack_syms;
3896 };
3897
3898 /* Descend the call graph for FUN, accumulating total stack required.  */
3899
3900 static bfd_boolean
3901 sum_stack (struct function_info *fun,
3902            struct bfd_link_info *info,
3903            void *param)
3904 {
3905   struct call_info *call;
3906   struct function_info *max;
3907   size_t stack, cum_stack;
3908   const char *f1;
3909   bfd_boolean has_call;
3910   struct _sum_stack_param *sum_stack_param = param;
3911   struct spu_link_hash_table *htab;
3912
3913   cum_stack = fun->stack;
3914   sum_stack_param->cum_stack = cum_stack;
3915   if (fun->visit3)
3916     return TRUE;
3917
3918   has_call = FALSE;
3919   max = NULL;
3920   for (call = fun->call_list; call; call = call->next)
3921     {
3922       if (!call->is_pasted)
3923         has_call = TRUE;
3924       if (!sum_stack (call->fun, info, sum_stack_param))
3925         return FALSE;
3926       stack = sum_stack_param->cum_stack;
3927       /* Include caller stack for normal calls, don't do so for
3928          tail calls.  fun->stack here is local stack usage for
3929          this function.  */
3930       if (!call->is_tail || call->is_pasted || call->fun->start != NULL)
3931         stack += fun->stack;
3932       if (cum_stack < stack)
3933         {
3934           cum_stack = stack;
3935           max = call->fun;
3936         }
3937     }
3938
3939   sum_stack_param->cum_stack = cum_stack;
3940   stack = fun->stack;
3941   /* Now fun->stack holds cumulative stack.  */
3942   fun->stack = cum_stack;
3943   fun->visit3 = TRUE;
3944
3945   if (!fun->non_root
3946       && sum_stack_param->overall_stack < cum_stack)
3947     sum_stack_param->overall_stack = cum_stack;
3948
3949   htab = spu_hash_table (info);
3950   if (htab->params->auto_overlay)
3951     return TRUE;
3952
3953   f1 = func_name (fun);
3954   if (htab->params->stack_analysis)
3955     {
3956       if (!fun->non_root)
3957         info->callbacks->info (_("  %s: 0x%v\n"), f1, (bfd_vma) cum_stack);
3958       info->callbacks->minfo (_("%s: 0x%v 0x%v\n"),
3959                               f1, (bfd_vma) stack, (bfd_vma) cum_stack);
3960
3961       if (has_call)
3962         {
3963           info->callbacks->minfo (_("  calls:\n"));
3964           for (call = fun->call_list; call; call = call->next)
3965             if (!call->is_pasted)
3966               {
3967                 const char *f2 = func_name (call->fun);
3968                 const char *ann1 = call->fun == max ? "*" : " ";
3969                 const char *ann2 = call->is_tail ? "t" : " ";
3970
3971                 info->callbacks->minfo (_("   %s%s %s\n"), ann1, ann2, f2);
3972               }
3973         }
3974     }
3975
3976   if (sum_stack_param->emit_stack_syms)
3977     {
3978       char *name = bfd_malloc (18 + strlen (f1));
3979       struct elf_link_hash_entry *h;
3980
3981       if (name == NULL)
3982         return FALSE;
3983
3984       if (fun->global || ELF_ST_BIND (fun->u.sym->st_info) == STB_GLOBAL)
3985         sprintf (name, "__stack_%s", f1);
3986       else
3987         sprintf (name, "__stack_%x_%s", fun->sec->id & 0xffffffff, f1);
3988
3989       h = elf_link_hash_lookup (&htab->elf, name, TRUE, TRUE, FALSE);
3990       free (name);
3991       if (h != NULL
3992           && (h->root.type == bfd_link_hash_new
3993               || h->root.type == bfd_link_hash_undefined
3994               || h->root.type == bfd_link_hash_undefweak))
3995         {
3996           h->root.type = bfd_link_hash_defined;
3997           h->root.u.def.section = bfd_abs_section_ptr;
3998           h->root.u.def.value = cum_stack;
3999           h->size = 0;
4000           h->type = 0;
4001           h->ref_regular = 1;
4002           h->def_regular = 1;
4003           h->ref_regular_nonweak = 1;
4004           h->forced_local = 1;
4005           h->non_elf = 0;
4006         }
4007     }
4008
4009   return TRUE;
4010 }
4011
4012 /* SEC is part of a pasted function.  Return the call_info for the
4013    next section of this function.  */
4014
4015 static struct call_info *
4016 find_pasted_call (asection *sec)
4017 {
4018   struct _spu_elf_section_data *sec_data = spu_elf_section_data (sec);
4019   struct spu_elf_stack_info *sinfo = sec_data->u.i.stack_info;
4020   struct call_info *call;
4021   int k;
4022
4023   for (k = 0; k < sinfo->num_fun; ++k)
4024     for (call = sinfo->fun[k].call_list; call != NULL; call = call->next)
4025       if (call->is_pasted)
4026         return call;
4027   abort ();
4028   return 0;
4029 }
4030
4031 /* qsort predicate to sort bfds by file name.  */
4032
4033 static int
4034 sort_bfds (const void *a, const void *b)
4035 {
4036   bfd *const *abfd1 = a;
4037   bfd *const *abfd2 = b;
4038
4039   return strcmp ((*abfd1)->filename, (*abfd2)->filename);
4040 }
4041
4042 static unsigned int
4043 print_one_overlay_section (FILE *script,
4044                            unsigned int base,
4045                            unsigned int count,
4046                            unsigned int ovlynum,
4047                            unsigned int *ovly_map,
4048                            asection **ovly_sections,
4049                            struct bfd_link_info *info)
4050 {
4051   unsigned int j;
4052
4053   for (j = base; j < count && ovly_map[j] == ovlynum; j++)
4054     {
4055       asection *sec = ovly_sections[2 * j];
4056
4057       if (fprintf (script, "   %s%c%s (%s)\n",
4058                    (sec->owner->my_archive != NULL
4059                     ? sec->owner->my_archive->filename : ""),
4060                    info->path_separator,
4061                    sec->owner->filename,
4062                    sec->name) <= 0)
4063         return -1;
4064       if (sec->segment_mark)
4065         {
4066           struct call_info *call = find_pasted_call (sec);
4067           while (call != NULL)
4068             {
4069               struct function_info *call_fun = call->fun;
4070               sec = call_fun->sec;
4071               if (fprintf (script, "   %s%c%s (%s)\n",
4072                            (sec->owner->my_archive != NULL
4073                             ? sec->owner->my_archive->filename : ""),
4074                            info->path_separator,
4075                            sec->owner->filename,
4076                            sec->name) <= 0)
4077                 return -1;
4078               for (call = call_fun->call_list; call; call = call->next)
4079                 if (call->is_pasted)
4080                   break;
4081             }
4082         }
4083     }
4084
4085   for (j = base; j < count && ovly_map[j] == ovlynum; j++)
4086     {
4087       asection *sec = ovly_sections[2 * j + 1];
4088       if (sec != NULL
4089           && fprintf (script, "   %s%c%s (%s)\n",
4090                       (sec->owner->my_archive != NULL
4091                        ? sec->owner->my_archive->filename : ""),
4092                       info->path_separator,
4093                       sec->owner->filename,
4094                       sec->name) <= 0)
4095         return -1;
4096
4097       sec = ovly_sections[2 * j];
4098       if (sec->segment_mark)
4099         {
4100           struct call_info *call = find_pasted_call (sec);
4101           while (call != NULL)
4102             {
4103               struct function_info *call_fun = call->fun;
4104               sec = call_fun->rodata;
4105               if (sec != NULL
4106                   && fprintf (script, "   %s%c%s (%s)\n",
4107                               (sec->owner->my_archive != NULL
4108                                ? sec->owner->my_archive->filename : ""),
4109                               info->path_separator,
4110                               sec->owner->filename,
4111                               sec->name) <= 0)
4112                 return -1;
4113               for (call = call_fun->call_list; call; call = call->next)
4114                 if (call->is_pasted)
4115                   break;
4116             }
4117         }
4118     }
4119
4120   return j;
4121 }
4122
4123 /* Handle --auto-overlay.  */
4124
4125 static void
4126 spu_elf_auto_overlay (struct bfd_link_info *info)
4127 {
4128   bfd *ibfd;
4129   bfd **bfd_arr;
4130   struct elf_segment_map *m;
4131   unsigned int fixed_size, lo, hi;
4132   struct spu_link_hash_table *htab;
4133   unsigned int base, i, count, bfd_count;
4134   unsigned int region, ovlynum;
4135   asection **ovly_sections, **ovly_p;
4136   unsigned int *ovly_map;
4137   FILE *script;
4138   unsigned int total_overlay_size, overlay_size;
4139   const char *ovly_mgr_entry;
4140   struct elf_link_hash_entry *h;
4141   struct _mos_param mos_param;
4142   struct _uos_param uos_param;
4143   struct function_info dummy_caller;
4144
4145   /* Find the extents of our loadable image.  */
4146   lo = (unsigned int) -1;
4147   hi = 0;
4148   for (m = elf_tdata (info->output_bfd)->segment_map; m != NULL; m = m->next)
4149     if (m->p_type == PT_LOAD)
4150       for (i = 0; i < m->count; i++)
4151         if (m->sections[i]->size != 0)
4152           {
4153             if (m->sections[i]->vma < lo)
4154               lo = m->sections[i]->vma;
4155             if (m->sections[i]->vma + m->sections[i]->size - 1 > hi)
4156               hi = m->sections[i]->vma + m->sections[i]->size - 1;
4157           }
4158   fixed_size = hi + 1 - lo;
4159
4160   if (!discover_functions (info))
4161     goto err_exit;
4162
4163   if (!build_call_tree (info))
4164     goto err_exit;
4165
4166   htab = spu_hash_table (info);
4167   if (htab->reserved == 0)
4168     {
4169       struct _sum_stack_param sum_stack_param;
4170
4171       sum_stack_param.emit_stack_syms = 0;
4172       sum_stack_param.overall_stack = 0;
4173       if (!for_each_node (sum_stack, info, &sum_stack_param, TRUE))
4174         goto err_exit;
4175       htab->reserved = sum_stack_param.overall_stack + htab->extra_stack_space;
4176     }
4177
4178   /* No need for overlays if everything already fits.  */
4179   if (fixed_size + htab->reserved <= htab->local_store
4180       && htab->params->ovly_flavour != ovly_soft_icache)
4181     {
4182       htab->params->auto_overlay = 0;
4183       return;
4184     }
4185
4186   uos_param.exclude_input_section = 0;
4187   uos_param.exclude_output_section
4188     = bfd_get_section_by_name (info->output_bfd, ".interrupt");
4189
4190   ovly_mgr_entry = "__ovly_load";
4191   if (htab->params->ovly_flavour == ovly_soft_icache)
4192     ovly_mgr_entry = "__icache_br_handler";
4193   h = elf_link_hash_lookup (&htab->elf, ovly_mgr_entry,
4194                             FALSE, FALSE, FALSE);
4195   if (h != NULL
4196       && (h->root.type == bfd_link_hash_defined
4197           || h->root.type == bfd_link_hash_defweak)
4198       && h->def_regular)
4199     {
4200       /* We have a user supplied overlay manager.  */
4201       uos_param.exclude_input_section = h->root.u.def.section;
4202     }
4203   else
4204     {
4205       /* If no user overlay manager, spu_elf_load_ovl_mgr will add our
4206          builtin version to .text, and will adjust .text size.  */
4207       fixed_size += (*htab->params->spu_elf_load_ovl_mgr) ();
4208     }
4209
4210   /* Mark overlay sections, and find max overlay section size.  */
4211   mos_param.max_overlay_size = 0;
4212   if (!for_each_node (mark_overlay_section, info, &mos_param, TRUE))
4213     goto err_exit;
4214
4215   /* We can't put the overlay manager or interrupt routines in
4216      overlays.  */
4217   uos_param.clearing = 0;
4218   if ((uos_param.exclude_input_section
4219        || uos_param.exclude_output_section)
4220       && !for_each_node (unmark_overlay_section, info, &uos_param, TRUE))
4221     goto err_exit;
4222
4223   bfd_count = 0;
4224   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
4225     ++bfd_count;
4226   bfd_arr = bfd_malloc (bfd_count * sizeof (*bfd_arr));
4227   if (bfd_arr == NULL)
4228     goto err_exit;
4229
4230   /* Count overlay sections, and subtract their sizes from "fixed_size".  */
4231   count = 0;
4232   bfd_count = 0;
4233   total_overlay_size = 0;
4234   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
4235     {
4236       extern const bfd_target bfd_elf32_spu_vec;
4237       asection *sec;
4238       unsigned int old_count;
4239
4240       if (ibfd->xvec != &bfd_elf32_spu_vec)
4241         continue;
4242
4243       old_count = count;
4244       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
4245         if (sec->linker_mark)
4246           {
4247             if ((sec->flags & SEC_CODE) != 0)
4248               count += 1;
4249             fixed_size -= sec->size;
4250             total_overlay_size += sec->size;
4251           }
4252         else if ((sec->flags & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD)
4253                  && sec->output_section->owner == info->output_bfd
4254                  && strncmp (sec->output_section->name, ".ovl.init", 9) == 0)
4255           fixed_size -= sec->size;
4256       if (count != old_count)
4257         bfd_arr[bfd_count++] = ibfd;
4258     }
4259
4260   /* Since the overlay link script selects sections by file name and
4261      section name, ensure that file names are unique.  */
4262   if (bfd_count > 1)
4263     {
4264       bfd_boolean ok = TRUE;
4265
4266       qsort (bfd_arr, bfd_count, sizeof (*bfd_arr), sort_bfds);
4267       for (i = 1; i < bfd_count; ++i)
4268         if (strcmp (bfd_arr[i - 1]->filename, bfd_arr[i]->filename) == 0)
4269           {
4270             if (bfd_arr[i - 1]->my_archive == bfd_arr[i]->my_archive)
4271               {
4272                 if (bfd_arr[i - 1]->my_archive && bfd_arr[i]->my_archive)
4273                   info->callbacks->einfo (_("%s duplicated in %s\n"),
4274                                           bfd_arr[i]->filename,
4275                                           bfd_arr[i]->my_archive->filename);
4276                 else
4277                   info->callbacks->einfo (_("%s duplicated\n"),
4278                                           bfd_arr[i]->filename);
4279                 ok = FALSE;
4280               }
4281           }
4282       if (!ok)
4283         {
4284           info->callbacks->einfo (_("sorry, no support for duplicate "
4285                                     "object files in auto-overlay script\n"));
4286           bfd_set_error (bfd_error_bad_value);
4287           goto err_exit;
4288         }
4289     }
4290   free (bfd_arr);
4291
4292   fixed_size += htab->reserved;
4293   fixed_size += htab->non_ovly_stub * ovl_stub_size (htab->params);
4294   if (fixed_size + mos_param.max_overlay_size <= htab->local_store)
4295     {
4296       if (htab->params->ovly_flavour == ovly_soft_icache)
4297         {
4298           /* Stubs in the non-icache area are bigger.  */
4299           fixed_size += htab->non_ovly_stub * 16;
4300           /* Space for icache manager tables.
4301              a) Tag array, one quadword per cache line.
4302              - word 0: ia address of present line, init to zero.  */
4303           fixed_size += 16 << htab->num_lines_log2;
4304           /* b) Rewrite "to" list, one quadword per cache line.  */
4305           fixed_size += 16 << htab->num_lines_log2;
4306           /* c) Rewrite "from" list, one byte per outgoing branch (rounded up
4307                 to a power-of-two number of full quadwords) per cache line.  */
4308           fixed_size += 16 << (htab->fromelem_size_log2
4309                                + htab->num_lines_log2);
4310           /* d) Pointer to __ea backing store (toe), 1 quadword.  */
4311           fixed_size += 16;
4312         }
4313       else
4314         {
4315           /* Guess number of overlays.  Assuming overlay buffer is on
4316              average only half full should be conservative.  */
4317           ovlynum = (total_overlay_size * 2 * htab->params->num_lines
4318                      / (htab->local_store - fixed_size));
4319           /* Space for _ovly_table[], _ovly_buf_table[] and toe.  */
4320           fixed_size += ovlynum * 16 + 16 + 4 + 16;
4321         }
4322     }
4323
4324   if (fixed_size + mos_param.max_overlay_size > htab->local_store)
4325     info->callbacks->einfo (_("non-overlay size of 0x%v plus maximum overlay "
4326                               "size of 0x%v exceeds local store\n"),
4327                             (bfd_vma) fixed_size,
4328                             (bfd_vma) mos_param.max_overlay_size);
4329
4330   /* Now see if we should put some functions in the non-overlay area.  */
4331   else if (fixed_size < htab->overlay_fixed)
4332     {
4333       unsigned int max_fixed, lib_size;
4334
4335       max_fixed = htab->local_store - mos_param.max_overlay_size;
4336       if (max_fixed > htab->overlay_fixed)
4337         max_fixed = htab->overlay_fixed;
4338       lib_size = max_fixed - fixed_size;
4339       lib_size = auto_ovl_lib_functions (info, lib_size);
4340       if (lib_size == (unsigned int) -1)
4341         goto err_exit;
4342       fixed_size = max_fixed - lib_size;
4343     }
4344
4345   /* Build an array of sections, suitably sorted to place into
4346      overlays.  */
4347   ovly_sections = bfd_malloc (2 * count * sizeof (*ovly_sections));
4348   if (ovly_sections == NULL)
4349     goto err_exit;
4350   ovly_p = ovly_sections;
4351   if (!for_each_node (collect_overlays, info, &ovly_p, TRUE))
4352     goto err_exit;
4353   count = (size_t) (ovly_p - ovly_sections) / 2;
4354   ovly_map = bfd_malloc (count * sizeof (*ovly_map));
4355   if (ovly_map == NULL)
4356     goto err_exit;
4357
4358   memset (&dummy_caller, 0, sizeof (dummy_caller));
4359   overlay_size = (htab->local_store - fixed_size) / htab->params->num_lines;
4360   if (htab->params->line_size != 0)
4361     overlay_size = htab->params->line_size;
4362   base = 0;
4363   ovlynum = 0;
4364   while (base < count)
4365     {
4366       unsigned int size = 0;
4367
4368       for (i = base; i < count; i++)
4369         {
4370           asection *sec;
4371           unsigned int tmp;
4372           unsigned int num_stubs;
4373           struct call_info *call, *pasty;
4374           struct _spu_elf_section_data *sec_data;
4375           struct spu_elf_stack_info *sinfo;
4376           int k;
4377
4378           /* See whether we can add this section to the current
4379              overlay without overflowing our overlay buffer.  */
4380           sec = ovly_sections[2 * i];
4381           tmp = size + sec->size;
4382           if (ovly_sections[2 * i + 1])
4383             tmp += ovly_sections[2 * i + 1]->size;
4384           if (tmp > overlay_size)
4385             break;
4386           if (sec->segment_mark)
4387             {
4388               /* Pasted sections must stay together, so add their
4389                  sizes too.  */
4390               struct call_info *pasty = find_pasted_call (sec);
4391               while (pasty != NULL)
4392                 {
4393                   struct function_info *call_fun = pasty->fun;
4394                   tmp += call_fun->sec->size;
4395                   if (call_fun->rodata)
4396                     tmp += call_fun->rodata->size;
4397                   for (pasty = call_fun->call_list; pasty; pasty = pasty->next)
4398                     if (pasty->is_pasted)
4399                       break;
4400                 }
4401             }
4402           if (tmp > overlay_size)
4403             break;
4404
4405           /* If we add this section, we might need new overlay call
4406              stubs.  Add any overlay section calls to dummy_call.  */
4407           pasty = NULL;
4408           sec_data = spu_elf_section_data (sec);
4409           sinfo = sec_data->u.i.stack_info;
4410           for (k = 0; k < sinfo->num_fun; ++k)
4411             for (call = sinfo->fun[k].call_list; call; call = call->next)
4412               if (call->is_pasted)
4413                 {
4414                   BFD_ASSERT (pasty == NULL);
4415                   pasty = call;
4416                 }
4417               else if (call->fun->sec->linker_mark)
4418                 {
4419                   if (!copy_callee (&dummy_caller, call))
4420                     goto err_exit;
4421                 }
4422           while (pasty != NULL)
4423             {
4424               struct function_info *call_fun = pasty->fun;
4425               pasty = NULL;
4426               for (call = call_fun->call_list; call; call = call->next)
4427                 if (call->is_pasted)
4428                   {
4429                     BFD_ASSERT (pasty == NULL);
4430                     pasty = call;
4431                   }
4432                 else if (!copy_callee (&dummy_caller, call))
4433                   goto err_exit;
4434             }
4435
4436           /* Calculate call stub size.  */
4437           num_stubs = 0;
4438           for (call = dummy_caller.call_list; call; call = call->next)
4439             {
4440               unsigned int k;
4441
4442               ++num_stubs;
4443               /* If the call is within this overlay, we won't need a
4444                  stub.  */
4445               for (k = base; k < i + 1; k++)
4446                 if (call->fun->sec == ovly_sections[2 * k])
4447                   {
4448                     --num_stubs;
4449                     break;
4450                   }
4451             }
4452           if (htab->params->ovly_flavour == ovly_soft_icache
4453               && num_stubs > htab->params->max_branch)
4454             break;
4455           if (tmp + num_stubs * ovl_stub_size (htab->params)
4456               > overlay_size)
4457             break;
4458           size = tmp;
4459         }
4460
4461       if (i == base)
4462         {
4463           info->callbacks->einfo (_("%B:%A%s exceeds overlay size\n"),
4464                                   ovly_sections[2 * i]->owner,
4465                                   ovly_sections[2 * i],
4466                                   ovly_sections[2 * i + 1] ? " + rodata" : "");
4467           bfd_set_error (bfd_error_bad_value);
4468           goto err_exit;
4469         }
4470
4471       while (dummy_caller.call_list != NULL)
4472         {
4473           struct call_info *call = dummy_caller.call_list;
4474           dummy_caller.call_list = call->next;
4475           free (call);
4476         }
4477
4478       ++ovlynum;
4479       while (base < i)
4480         ovly_map[base++] = ovlynum;
4481     }
4482
4483   script = htab->params->spu_elf_open_overlay_script ();
4484
4485   if (fprintf (script, "SECTIONS\n{\n") <= 0)
4486     goto file_err;
4487
4488   if (htab->params->ovly_flavour == ovly_soft_icache)
4489     {
4490       if (fprintf (script,
4491                    " .data.icache ALIGN (16) : { *(.ovtab) *(.data.icache) }\n"
4492                    " . = ALIGN (%u);\n"
4493                    " .ovl.init : { *(.ovl.init) }\n"
4494                    " . = ABSOLUTE (ADDR (.ovl.init));\n",
4495                    htab->params->line_size) <= 0)
4496         goto file_err;
4497
4498       base = 0;
4499       ovlynum = 1;
4500       while (base < count)
4501         {
4502           unsigned int indx = ovlynum - 1;
4503           unsigned int vma, lma;
4504
4505           vma = (indx & (htab->params->num_lines - 1)) << htab->line_size_log2;
4506           lma = indx << htab->line_size_log2;
4507
4508           if (fprintf (script, " .ovly%u ABSOLUTE (ADDR (.ovl.init)) + %u "
4509                        ": AT (ALIGN (LOADADDR (.ovl.init) + SIZEOF (.ovl.init), 16) + %u) {\n",
4510                        ovlynum, vma, lma) <= 0)
4511             goto file_err;
4512
4513           base = print_one_overlay_section (script, base, count, ovlynum,
4514                                             ovly_map, ovly_sections, info);
4515           if (base == (unsigned) -1)
4516             goto file_err;
4517
4518           if (fprintf (script, "  }\n") <= 0)
4519             goto file_err;
4520
4521           ovlynum++;
4522         }
4523
4524       if (fprintf (script, " . = ABSOLUTE (ADDR (.ovl.init)) + %u;\n",
4525                    1 << (htab->num_lines_log2 + htab->line_size_log2)) <= 0)
4526         goto file_err;
4527     }
4528   else
4529     {
4530       if (fprintf (script,
4531                    " . = ALIGN (16);\n"
4532                    " .ovl.init : { *(.ovl.init) }\n"
4533                    " . = ABSOLUTE (ADDR (.ovl.init));\n") <= 0)
4534         goto file_err;
4535
4536       for (region = 1; region <= htab->params->num_lines; region++)
4537         {
4538           ovlynum = region;
4539           base = 0;
4540           while (base < count && ovly_map[base] < ovlynum)
4541             base++;
4542
4543           if (base == count)
4544             break;
4545
4546           if (region == 1)
4547             {
4548               /* We need to set lma since we are overlaying .ovl.init.  */
4549               if (fprintf (script,
4550                            " OVERLAY : AT (ALIGN (LOADADDR (.ovl.init) + SIZEOF (.ovl.init), 16))\n {\n") <= 0)
4551                 goto file_err;
4552             }
4553           else
4554             {
4555               if (fprintf (script, " OVERLAY :\n {\n") <= 0)
4556                 goto file_err;
4557             }
4558
4559           while (base < count)
4560             {
4561               if (fprintf (script, "  .ovly%u {\n", ovlynum) <= 0)
4562                 goto file_err;
4563
4564               base = print_one_overlay_section (script, base, count, ovlynum,
4565                                                 ovly_map, ovly_sections, info);
4566               if (base == (unsigned) -1)
4567                 goto file_err;
4568
4569               if (fprintf (script, "  }\n") <= 0)
4570                 goto file_err;
4571
4572               ovlynum += htab->params->num_lines;
4573               while (base < count && ovly_map[base] < ovlynum)
4574                 base++;
4575             }
4576
4577           if (fprintf (script, " }\n") <= 0)
4578             goto file_err;
4579         }
4580
4581     }
4582
4583   free (ovly_map);
4584   free (ovly_sections);
4585
4586   if (fprintf (script, "}\nINSERT BEFORE .text;\n") <= 0)
4587     goto file_err;
4588   if (fclose (script) != 0)
4589     goto file_err;
4590
4591   if (htab->params->auto_overlay & AUTO_RELINK)
4592     (*htab->params->spu_elf_relink) ();
4593
4594   xexit (0);
4595
4596  file_err:
4597   bfd_set_error (bfd_error_system_call);
4598  err_exit:
4599   info->callbacks->einfo ("%F%P: auto overlay error: %E\n");
4600   xexit (1);
4601 }
4602
4603 /* Provide an estimate of total stack required.  */
4604
4605 static bfd_boolean
4606 spu_elf_stack_analysis (struct bfd_link_info *info)
4607 {
4608   struct spu_link_hash_table *htab;
4609   struct _sum_stack_param sum_stack_param;
4610
4611   if (!discover_functions (info))
4612     return FALSE;
4613
4614   if (!build_call_tree (info))
4615     return FALSE;
4616
4617   htab = spu_hash_table (info);
4618   if (htab->params->stack_analysis)
4619     {
4620       info->callbacks->info (_("Stack size for call graph root nodes.\n"));
4621       info->callbacks->minfo (_("\nStack size for functions.  "
4622                                 "Annotations: '*' max stack, 't' tail call\n"));
4623     }
4624
4625   sum_stack_param.emit_stack_syms = htab->params->emit_stack_syms;
4626   sum_stack_param.overall_stack = 0;
4627   if (!for_each_node (sum_stack, info, &sum_stack_param, TRUE))
4628     return FALSE;
4629
4630   if (htab->params->stack_analysis)
4631     info->callbacks->info (_("Maximum stack required is 0x%v\n"),
4632                            (bfd_vma) sum_stack_param.overall_stack);
4633   return TRUE;
4634 }
4635
4636 /* Perform a final link.  */
4637
4638 static bfd_boolean
4639 spu_elf_final_link (bfd *output_bfd, struct bfd_link_info *info)
4640 {
4641   struct spu_link_hash_table *htab = spu_hash_table (info);
4642
4643   if (htab->params->auto_overlay)
4644     spu_elf_auto_overlay (info);
4645
4646   if ((htab->params->stack_analysis
4647        || (htab->params->ovly_flavour == ovly_soft_icache
4648            && htab->params->lrlive_analysis))
4649       && !spu_elf_stack_analysis (info))
4650     info->callbacks->einfo ("%X%P: stack/lrlive analysis error: %E\n");
4651
4652   if (!spu_elf_build_stubs (info))
4653     info->callbacks->einfo ("%F%P: can not build overlay stubs: %E\n");
4654
4655   return bfd_elf_final_link (output_bfd, info);
4656 }
4657
4658 /* Called when not normally emitting relocs, ie. !info->relocatable
4659    and !info->emitrelocations.  Returns a count of special relocs
4660    that need to be emitted.  */
4661
4662 static unsigned int
4663 spu_elf_count_relocs (struct bfd_link_info *info, asection *sec)
4664 {
4665   Elf_Internal_Rela *relocs;
4666   unsigned int count = 0;
4667
4668   relocs = _bfd_elf_link_read_relocs (sec->owner, sec, NULL, NULL,
4669                                       info->keep_memory);
4670   if (relocs != NULL)
4671     {
4672       Elf_Internal_Rela *rel;
4673       Elf_Internal_Rela *relend = relocs + sec->reloc_count;
4674
4675       for (rel = relocs; rel < relend; rel++)
4676         {
4677           int r_type = ELF32_R_TYPE (rel->r_info);
4678           if (r_type == R_SPU_PPU32 || r_type == R_SPU_PPU64)
4679             ++count;
4680         }
4681
4682       if (elf_section_data (sec)->relocs != relocs)
4683         free (relocs);
4684     }
4685
4686   return count;
4687 }
4688
4689 /* Apply RELOCS to CONTENTS of INPUT_SECTION from INPUT_BFD.  */
4690
4691 static int
4692 spu_elf_relocate_section (bfd *output_bfd,
4693                           struct bfd_link_info *info,
4694                           bfd *input_bfd,
4695                           asection *input_section,
4696                           bfd_byte *contents,
4697                           Elf_Internal_Rela *relocs,
4698                           Elf_Internal_Sym *local_syms,
4699                           asection **local_sections)
4700 {
4701   Elf_Internal_Shdr *symtab_hdr;
4702   struct elf_link_hash_entry **sym_hashes;
4703   Elf_Internal_Rela *rel, *relend;
4704   struct spu_link_hash_table *htab;
4705   asection *ea;
4706   int ret = TRUE;
4707   bfd_boolean emit_these_relocs = FALSE;
4708   bfd_boolean is_ea_sym;
4709   bfd_boolean stubs;
4710   unsigned int iovl = 0;
4711
4712   htab = spu_hash_table (info);
4713   stubs = (htab->stub_sec != NULL
4714            && maybe_needs_stubs (input_section));
4715   iovl = overlay_index (input_section);
4716   ea = bfd_get_section_by_name (output_bfd, "._ea");
4717   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
4718   sym_hashes = (struct elf_link_hash_entry **) (elf_sym_hashes (input_bfd));
4719
4720   rel = relocs;
4721   relend = relocs + input_section->reloc_count;
4722   for (; rel < relend; rel++)
4723     {
4724       int r_type;
4725       reloc_howto_type *howto;
4726       unsigned int r_symndx;
4727       Elf_Internal_Sym *sym;
4728       asection *sec;
4729       struct elf_link_hash_entry *h;
4730       const char *sym_name;
4731       bfd_vma relocation;
4732       bfd_vma addend;
4733       bfd_reloc_status_type r;
4734       bfd_boolean unresolved_reloc;
4735       bfd_boolean warned;
4736       enum _stub_type stub_type;
4737
4738       r_symndx = ELF32_R_SYM (rel->r_info);
4739       r_type = ELF32_R_TYPE (rel->r_info);
4740       howto = elf_howto_table + r_type;
4741       unresolved_reloc = FALSE;
4742       warned = FALSE;
4743       h = NULL;
4744       sym = NULL;
4745       sec = NULL;
4746       if (r_symndx < symtab_hdr->sh_info)
4747         {
4748           sym = local_syms + r_symndx;
4749           sec = local_sections[r_symndx];
4750           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
4751           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
4752         }
4753       else
4754         {
4755           if (sym_hashes == NULL)
4756             return FALSE;
4757
4758           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4759
4760           while (h->root.type == bfd_link_hash_indirect
4761                  || h->root.type == bfd_link_hash_warning)
4762             h = (struct elf_link_hash_entry *) h->root.u.i.link;
4763
4764           relocation = 0;
4765           if (h->root.type == bfd_link_hash_defined
4766               || h->root.type == bfd_link_hash_defweak)
4767             {
4768               sec = h->root.u.def.section;
4769               if (sec == NULL
4770                   || sec->output_section == NULL)
4771                 /* Set a flag that will be cleared later if we find a
4772                    relocation value for this symbol.  output_section
4773                    is typically NULL for symbols satisfied by a shared
4774                    library.  */
4775                 unresolved_reloc = TRUE;
4776               else
4777                 relocation = (h->root.u.def.value
4778                               + sec->output_section->vma
4779                               + sec->output_offset);
4780             }
4781           else if (h->root.type == bfd_link_hash_undefweak)
4782             ;
4783           else if (info->unresolved_syms_in_objects == RM_IGNORE
4784                    && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
4785             ;
4786           else if (!info->relocatable
4787                    && !(r_type == R_SPU_PPU32 || r_type == R_SPU_PPU64))
4788             {
4789               bfd_boolean err;
4790               err = (info->unresolved_syms_in_objects == RM_GENERATE_ERROR
4791                      || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT);
4792               if (!info->callbacks->undefined_symbol (info,
4793                                                       h->root.root.string,
4794                                                       input_bfd,
4795                                                       input_section,
4796                                                       rel->r_offset, err))
4797                 return FALSE;
4798               warned = TRUE;
4799             }
4800           sym_name = h->root.root.string;
4801         }
4802
4803       if (sec != NULL && elf_discarded_section (sec))
4804         {
4805           /* For relocs against symbols from removed linkonce sections,
4806              or sections discarded by a linker script, we just want the
4807              section contents zeroed.  Avoid any special processing.  */
4808           _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
4809           rel->r_info = 0;
4810           rel->r_addend = 0;
4811           continue;
4812         }
4813
4814       if (info->relocatable)
4815         continue;
4816
4817       is_ea_sym = (ea != NULL
4818                    && sec != NULL
4819                    && sec->output_section == ea);
4820
4821       /* If this symbol is in an overlay area, we may need to relocate
4822          to the overlay stub.  */
4823       addend = rel->r_addend;
4824       if (stubs
4825           && !is_ea_sym
4826           && (stub_type = needs_ovl_stub (h, sym, sec, input_section, rel,
4827                                           contents, info)) != no_stub)
4828         {
4829           unsigned int ovl = 0;
4830           struct got_entry *g, **head;
4831
4832           if (stub_type != nonovl_stub)
4833             ovl = iovl;
4834
4835           if (h != NULL)
4836             head = &h->got.glist;
4837           else
4838             head = elf_local_got_ents (input_bfd) + r_symndx;
4839
4840           for (g = *head; g != NULL; g = g->next)
4841             if (htab->params->ovly_flavour == ovly_soft_icache
4842                 ? g->br_addr == (rel->r_offset
4843                                  + input_section->output_offset
4844                                  + input_section->output_section->vma)
4845                 : g->addend == addend && (g->ovl == ovl || g->ovl == 0))
4846               break;
4847           if (g == NULL)
4848             abort ();
4849
4850           relocation = g->stub_addr;
4851           addend = 0;
4852         }
4853       else
4854         {
4855           /* For soft icache, encode the overlay index into addresses.  */
4856           if (htab->params->ovly_flavour == ovly_soft_icache
4857               && (r_type == R_SPU_ADDR16_HI
4858                   || r_type == R_SPU_ADDR32 || r_type == R_SPU_REL32)
4859               && !is_ea_sym)
4860             {
4861               unsigned int ovl = overlay_index (sec);
4862               if (ovl != 0)
4863                 {
4864                   unsigned int set_id = ((ovl - 1) >> htab->num_lines_log2) + 1;
4865                   relocation += set_id << 18;
4866                 }
4867             }
4868         }
4869
4870       if (unresolved_reloc)
4871         ;
4872       else if (r_type == R_SPU_PPU32 || r_type == R_SPU_PPU64)
4873         {
4874           if (is_ea_sym)
4875             {
4876               /* ._ea is a special section that isn't allocated in SPU
4877                  memory, but rather occupies space in PPU memory as
4878                  part of an embedded ELF image.  If this reloc is
4879                  against a symbol defined in ._ea, then transform the
4880                  reloc into an equivalent one without a symbol
4881                  relative to the start of the ELF image.  */
4882               rel->r_addend += (relocation
4883                                 - ea->vma
4884                                 + elf_section_data (ea)->this_hdr.sh_offset);
4885               rel->r_info = ELF32_R_INFO (0, r_type);
4886             }
4887           emit_these_relocs = TRUE;
4888           continue;
4889         }
4890       else if (is_ea_sym)
4891         unresolved_reloc = TRUE;
4892
4893       if (unresolved_reloc)
4894         {
4895           (*_bfd_error_handler)
4896             (_("%B(%s+0x%lx): unresolvable %s relocation against symbol `%s'"),
4897              input_bfd,
4898              bfd_get_section_name (input_bfd, input_section),
4899              (long) rel->r_offset,
4900              howto->name,
4901              sym_name);
4902           ret = FALSE;
4903         }
4904
4905       r = _bfd_final_link_relocate (howto,
4906                                     input_bfd,
4907                                     input_section,
4908                                     contents,
4909                                     rel->r_offset, relocation, addend);
4910
4911       if (r != bfd_reloc_ok)
4912         {
4913           const char *msg = (const char *) 0;
4914
4915           switch (r)
4916             {
4917             case bfd_reloc_overflow:
4918               if (!((*info->callbacks->reloc_overflow)
4919                     (info, (h ? &h->root : NULL), sym_name, howto->name,
4920                      (bfd_vma) 0, input_bfd, input_section, rel->r_offset)))
4921                 return FALSE;
4922               break;
4923
4924             case bfd_reloc_undefined:
4925               if (!((*info->callbacks->undefined_symbol)
4926                     (info, sym_name, input_bfd, input_section,
4927                      rel->r_offset, TRUE)))
4928                 return FALSE;
4929               break;
4930
4931             case bfd_reloc_outofrange:
4932               msg = _("internal error: out of range error");
4933               goto common_error;
4934
4935             case bfd_reloc_notsupported:
4936               msg = _("internal error: unsupported relocation error");
4937               goto common_error;
4938
4939             case bfd_reloc_dangerous:
4940               msg = _("internal error: dangerous error");
4941               goto common_error;
4942
4943             default:
4944               msg = _("internal error: unknown error");
4945               /* fall through */
4946
4947             common_error:
4948               ret = FALSE;
4949               if (!((*info->callbacks->warning)
4950                     (info, msg, sym_name, input_bfd, input_section,
4951                      rel->r_offset)))
4952                 return FALSE;
4953               break;
4954             }
4955         }
4956     }
4957
4958   if (ret
4959       && emit_these_relocs
4960       && !info->emitrelocations)
4961     {
4962       Elf_Internal_Rela *wrel;
4963       Elf_Internal_Shdr *rel_hdr;
4964
4965       wrel = rel = relocs;
4966       relend = relocs + input_section->reloc_count;
4967       for (; rel < relend; rel++)
4968         {
4969           int r_type;
4970
4971           r_type = ELF32_R_TYPE (rel->r_info);
4972           if (r_type == R_SPU_PPU32 || r_type == R_SPU_PPU64)
4973             *wrel++ = *rel;
4974         }
4975       input_section->reloc_count = wrel - relocs;
4976       /* Backflips for _bfd_elf_link_output_relocs.  */
4977       rel_hdr = &elf_section_data (input_section)->rel_hdr;
4978       rel_hdr->sh_size = input_section->reloc_count * rel_hdr->sh_entsize;
4979       ret = 2;
4980     }
4981
4982   return ret;
4983 }
4984
4985 /* Adjust _SPUEAR_ syms to point at their overlay stubs.  */
4986
4987 static bfd_boolean
4988 spu_elf_output_symbol_hook (struct bfd_link_info *info,
4989                             const char *sym_name ATTRIBUTE_UNUSED,
4990                             Elf_Internal_Sym *sym,
4991                             asection *sym_sec ATTRIBUTE_UNUSED,
4992                             struct elf_link_hash_entry *h)
4993 {
4994   struct spu_link_hash_table *htab = spu_hash_table (info);
4995
4996   if (!info->relocatable
4997       && htab->stub_sec != NULL
4998       && h != NULL
4999       && (h->root.type == bfd_link_hash_defined
5000           || h->root.type == bfd_link_hash_defweak)
5001       && h->def_regular
5002       && strncmp (h->root.root.string, "_SPUEAR_", 8) == 0)
5003     {
5004       struct got_entry *g;
5005
5006       for (g = h->got.glist; g != NULL; g = g->next)
5007         if (htab->params->ovly_flavour == ovly_soft_icache
5008             ? g->br_addr == g->stub_addr
5009             : g->addend == 0 && g->ovl == 0)
5010           {
5011             sym->st_shndx = (_bfd_elf_section_from_bfd_section
5012                              (htab->stub_sec[0]->output_section->owner,
5013                               htab->stub_sec[0]->output_section));
5014             sym->st_value = g->stub_addr;
5015             break;
5016           }
5017     }
5018
5019   return TRUE;
5020 }
5021
5022 static int spu_plugin = 0;
5023
5024 void
5025 spu_elf_plugin (int val)
5026 {
5027   spu_plugin = val;
5028 }
5029
5030 /* Set ELF header e_type for plugins.  */
5031
5032 static void
5033 spu_elf_post_process_headers (bfd *abfd,
5034                               struct bfd_link_info *info ATTRIBUTE_UNUSED)
5035 {
5036   if (spu_plugin)
5037     {
5038       Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
5039
5040       i_ehdrp->e_type = ET_DYN;
5041     }
5042 }
5043
5044 /* We may add an extra PT_LOAD segment for .toe.  We also need extra
5045    segments for overlays.  */
5046
5047 static int
5048 spu_elf_additional_program_headers (bfd *abfd, struct bfd_link_info *info)
5049 {
5050   int extra = 0;
5051   asection *sec;
5052
5053   if (info != NULL)
5054     {
5055       struct spu_link_hash_table *htab = spu_hash_table (info);
5056       extra = htab->num_overlays;
5057     }
5058
5059   if (extra)
5060     ++extra;
5061
5062   sec = bfd_get_section_by_name (abfd, ".toe");
5063   if (sec != NULL && (sec->flags & SEC_LOAD) != 0)
5064     ++extra;
5065
5066   return extra;
5067 }
5068
5069 /* Remove .toe section from other PT_LOAD segments and put it in
5070    a segment of its own.  Put overlays in separate segments too.  */
5071
5072 static bfd_boolean
5073 spu_elf_modify_segment_map (bfd *abfd, struct bfd_link_info *info)
5074 {
5075   asection *toe, *s;
5076   struct elf_segment_map *m, *m_overlay;
5077   struct elf_segment_map **p, **p_overlay;
5078   unsigned int i;
5079
5080   if (info == NULL)
5081     return TRUE;
5082
5083   toe = bfd_get_section_by_name (abfd, ".toe");
5084   for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
5085     if (m->p_type == PT_LOAD && m->count > 1)
5086       for (i = 0; i < m->count; i++)
5087         if ((s = m->sections[i]) == toe
5088             || spu_elf_section_data (s)->u.o.ovl_index != 0)
5089           {
5090             struct elf_segment_map *m2;
5091             bfd_vma amt;
5092
5093             if (i + 1 < m->count)
5094               {
5095                 amt = sizeof (struct elf_segment_map);
5096                 amt += (m->count - (i + 2)) * sizeof (m->sections[0]);
5097                 m2 = bfd_zalloc (abfd, amt);
5098                 if (m2 == NULL)
5099                   return FALSE;
5100                 m2->count = m->count - (i + 1);
5101                 memcpy (m2->sections, m->sections + i + 1,
5102                         m2->count * sizeof (m->sections[0]));
5103                 m2->p_type = PT_LOAD;
5104                 m2->next = m->next;
5105                 m->next = m2;
5106               }
5107             m->count = 1;
5108             if (i != 0)
5109               {
5110                 m->count = i;
5111                 amt = sizeof (struct elf_segment_map);
5112                 m2 = bfd_zalloc (abfd, amt);
5113                 if (m2 == NULL)
5114                   return FALSE;
5115                 m2->p_type = PT_LOAD;
5116                 m2->count = 1;
5117                 m2->sections[0] = s;
5118                 m2->next = m->next;
5119                 m->next = m2;
5120               }
5121             break;
5122           }
5123
5124
5125   /* Some SPU ELF loaders ignore the PF_OVERLAY flag and just load all
5126      PT_LOAD segments.  This can cause the .ovl.init section to be
5127      overwritten with the contents of some overlay segment.  To work
5128      around this issue, we ensure that all PF_OVERLAY segments are
5129      sorted first amongst the program headers; this ensures that even
5130      with a broken loader, the .ovl.init section (which is not marked
5131      as PF_OVERLAY) will be placed into SPU local store on startup.  */
5132
5133   /* Move all overlay segments onto a separate list.  */
5134   p = &elf_tdata (abfd)->segment_map;
5135   p_overlay = &m_overlay;
5136   while (*p != NULL)
5137     {
5138       if ((*p)->p_type == PT_LOAD && (*p)->count == 1
5139           && spu_elf_section_data ((*p)->sections[0])->u.o.ovl_index != 0)
5140         {
5141           struct elf_segment_map *m = *p;
5142           *p = m->next;
5143           *p_overlay = m;
5144           p_overlay = &m->next;
5145           continue;
5146         }
5147
5148       p = &((*p)->next);
5149     }
5150
5151   /* Re-insert overlay segments at the head of the segment map.  */
5152   *p_overlay = elf_tdata (abfd)->segment_map;
5153   elf_tdata (abfd)->segment_map = m_overlay;
5154
5155   return TRUE;
5156 }
5157
5158 /* Tweak the section type of .note.spu_name.  */
5159
5160 static bfd_boolean
5161 spu_elf_fake_sections (bfd *obfd ATTRIBUTE_UNUSED,
5162                        Elf_Internal_Shdr *hdr,
5163                        asection *sec)
5164 {
5165   if (strcmp (sec->name, SPU_PTNOTE_SPUNAME) == 0)
5166     hdr->sh_type = SHT_NOTE;
5167   return TRUE;
5168 }
5169
5170 /* Tweak phdrs before writing them out.  */
5171
5172 static int
5173 spu_elf_modify_program_headers (bfd *abfd, struct bfd_link_info *info)
5174 {
5175   const struct elf_backend_data *bed;
5176   struct elf_obj_tdata *tdata;
5177   Elf_Internal_Phdr *phdr, *last;
5178   struct spu_link_hash_table *htab;
5179   unsigned int count;
5180   unsigned int i;
5181
5182   if (info == NULL)
5183     return TRUE;
5184
5185   bed = get_elf_backend_data (abfd);
5186   tdata = elf_tdata (abfd);
5187   phdr = tdata->phdr;
5188   count = tdata->program_header_size / bed->s->sizeof_phdr;
5189   htab = spu_hash_table (info);
5190   if (htab->num_overlays != 0)
5191     {
5192       struct elf_segment_map *m;
5193       unsigned int o;
5194
5195       for (i = 0, m = elf_tdata (abfd)->segment_map; m; ++i, m = m->next)
5196         if (m->count != 0
5197             && (o = spu_elf_section_data (m->sections[0])->u.o.ovl_index) != 0)
5198           {
5199             /* Mark this as an overlay header.  */
5200             phdr[i].p_flags |= PF_OVERLAY;
5201
5202             if (htab->ovtab != NULL && htab->ovtab->size != 0
5203                 && htab->params->ovly_flavour != ovly_soft_icache)
5204               {
5205                 bfd_byte *p = htab->ovtab->contents;
5206                 unsigned int off = o * 16 + 8;
5207
5208                 /* Write file_off into _ovly_table.  */
5209                 bfd_put_32 (htab->ovtab->owner, phdr[i].p_offset, p + off);
5210               }
5211           }
5212       /* Soft-icache has its file offset put in .ovl.init.  */
5213       if (htab->init != NULL && htab->init->size != 0)
5214         {
5215           bfd_vma val = elf_section_data (htab->ovl_sec[0])->this_hdr.sh_offset;
5216
5217           bfd_put_32 (htab->init->owner, val, htab->init->contents + 4);
5218         }
5219     }
5220
5221   /* Round up p_filesz and p_memsz of PT_LOAD segments to multiples
5222      of 16.  This should always be possible when using the standard
5223      linker scripts, but don't create overlapping segments if
5224      someone is playing games with linker scripts.  */
5225   last = NULL;
5226   for (i = count; i-- != 0; )
5227     if (phdr[i].p_type == PT_LOAD)
5228       {
5229         unsigned adjust;
5230
5231         adjust = -phdr[i].p_filesz & 15;
5232         if (adjust != 0
5233             && last != NULL
5234             && phdr[i].p_offset + phdr[i].p_filesz > last->p_offset - adjust)
5235           break;
5236
5237         adjust = -phdr[i].p_memsz & 15;
5238         if (adjust != 0
5239             && last != NULL
5240             && phdr[i].p_filesz != 0
5241             && phdr[i].p_vaddr + phdr[i].p_memsz > last->p_vaddr - adjust
5242             && phdr[i].p_vaddr + phdr[i].p_memsz <= last->p_vaddr)
5243           break;
5244
5245         if (phdr[i].p_filesz != 0)
5246           last = &phdr[i];
5247       }
5248
5249   if (i == (unsigned int) -1)
5250     for (i = count; i-- != 0; )
5251       if (phdr[i].p_type == PT_LOAD)
5252         {
5253         unsigned adjust;
5254
5255         adjust = -phdr[i].p_filesz & 15;
5256         phdr[i].p_filesz += adjust;
5257
5258         adjust = -phdr[i].p_memsz & 15;
5259         phdr[i].p_memsz += adjust;
5260       }
5261
5262   return TRUE;
5263 }
5264
5265 #define TARGET_BIG_SYM          bfd_elf32_spu_vec
5266 #define TARGET_BIG_NAME         "elf32-spu"
5267 #define ELF_ARCH                bfd_arch_spu
5268 #define ELF_MACHINE_CODE        EM_SPU
5269 /* This matches the alignment need for DMA.  */
5270 #define ELF_MAXPAGESIZE         0x80
5271 #define elf_backend_rela_normal         1
5272 #define elf_backend_can_gc_sections     1
5273
5274 #define bfd_elf32_bfd_reloc_type_lookup         spu_elf_reloc_type_lookup
5275 #define bfd_elf32_bfd_reloc_name_lookup         spu_elf_reloc_name_lookup
5276 #define elf_info_to_howto                       spu_elf_info_to_howto
5277 #define elf_backend_count_relocs                spu_elf_count_relocs
5278 #define elf_backend_relocate_section            spu_elf_relocate_section
5279 #define elf_backend_symbol_processing           spu_elf_backend_symbol_processing
5280 #define elf_backend_link_output_symbol_hook     spu_elf_output_symbol_hook
5281 #define elf_backend_object_p                    spu_elf_object_p
5282 #define bfd_elf32_new_section_hook              spu_elf_new_section_hook
5283 #define bfd_elf32_bfd_link_hash_table_create    spu_elf_link_hash_table_create
5284
5285 #define elf_backend_additional_program_headers  spu_elf_additional_program_headers
5286 #define elf_backend_modify_segment_map          spu_elf_modify_segment_map
5287 #define elf_backend_modify_program_headers      spu_elf_modify_program_headers
5288 #define elf_backend_post_process_headers        spu_elf_post_process_headers
5289 #define elf_backend_fake_sections               spu_elf_fake_sections
5290 #define elf_backend_special_sections            spu_elf_special_sections
5291 #define bfd_elf32_bfd_final_link                spu_elf_final_link
5292
5293 #include "elf32-target.h"