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     {
3403       unsigned int size;
3404
3405       fun->sec->linker_mark = 1;
3406       fun->sec->gc_mark = 1;
3407       fun->sec->segment_mark = 0;
3408       /* Ensure SEC_CODE is set on this text section (it ought to
3409          be!), and SEC_CODE is clear on rodata sections.  We use
3410          this flag to differentiate the two overlay section types.  */
3411       fun->sec->flags |= SEC_CODE;
3412
3413       size = fun->sec->size;
3414       if (htab->params->auto_overlay & OVERLAY_RODATA)
3415         {
3416           char *name = NULL;
3417
3418           /* Find the rodata section corresponding to this function's
3419              text section.  */
3420           if (strcmp (fun->sec->name, ".text") == 0)
3421             {
3422               name = bfd_malloc (sizeof (".rodata"));
3423               if (name == NULL)
3424                 return FALSE;
3425               memcpy (name, ".rodata", sizeof (".rodata"));
3426             }
3427           else if (strncmp (fun->sec->name, ".text.", 6) == 0)
3428             {
3429               size_t len = strlen (fun->sec->name);
3430               name = bfd_malloc (len + 3);
3431               if (name == NULL)
3432                 return FALSE;
3433               memcpy (name, ".rodata", sizeof (".rodata"));
3434               memcpy (name + 7, fun->sec->name + 5, len - 4);
3435             }
3436           else if (strncmp (fun->sec->name, ".gnu.linkonce.t.", 16) == 0)
3437             {
3438               size_t len = strlen (fun->sec->name) + 1;
3439               name = bfd_malloc (len);
3440               if (name == NULL)
3441                 return FALSE;
3442               memcpy (name, fun->sec->name, len);
3443               name[14] = 'r';
3444             }
3445
3446           if (name != NULL)
3447             {
3448               asection *rodata = NULL;
3449               asection *group_sec = elf_section_data (fun->sec)->next_in_group;
3450               if (group_sec == NULL)
3451                 rodata = bfd_get_section_by_name (fun->sec->owner, name);
3452               else
3453                 while (group_sec != NULL && group_sec != fun->sec)
3454                   {
3455                     if (strcmp (group_sec->name, name) == 0)
3456                       {
3457                         rodata = group_sec;
3458                         break;
3459                       }
3460                     group_sec = elf_section_data (group_sec)->next_in_group;
3461                   }
3462               fun->rodata = rodata;
3463               if (fun->rodata)
3464                 {
3465                   size += fun->rodata->size;
3466                   if (htab->params->line_size != 0
3467                       && size > htab->params->line_size)
3468                     {
3469                       size -= fun->rodata->size;
3470                       fun->rodata = NULL;
3471                     }
3472                   else
3473                     {
3474                       fun->rodata->linker_mark = 1;
3475                       fun->rodata->gc_mark = 1;
3476                       fun->rodata->flags &= ~SEC_CODE;
3477                     }
3478                 }
3479               free (name);
3480             }
3481         }
3482       if (mos_param->max_overlay_size < size)
3483         mos_param->max_overlay_size = size;
3484     }
3485
3486   for (count = 0, call = fun->call_list; call != NULL; call = call->next)
3487     count += 1;
3488
3489   if (count > 1)
3490     {
3491       struct call_info **calls = bfd_malloc (count * sizeof (*calls));
3492       if (calls == NULL)
3493         return FALSE;
3494
3495       for (count = 0, call = fun->call_list; call != NULL; call = call->next)
3496         calls[count++] = call;
3497
3498       qsort (calls, count, sizeof (*calls), sort_calls);
3499
3500       fun->call_list = NULL;
3501       while (count != 0)
3502         {
3503           --count;
3504           calls[count]->next = fun->call_list;
3505           fun->call_list = calls[count];
3506         }
3507       free (calls);
3508     }
3509
3510   for (call = fun->call_list; call != NULL; call = call->next)
3511     {
3512       if (call->is_pasted)
3513         {
3514           /* There can only be one is_pasted call per function_info.  */
3515           BFD_ASSERT (!fun->sec->segment_mark);
3516           fun->sec->segment_mark = 1;
3517         }
3518       if (!mark_overlay_section (call->fun, info, param))
3519         return FALSE;
3520     }
3521
3522   /* Don't put entry code into an overlay.  The overlay manager needs
3523      a stack!  Also, don't mark .ovl.init as an overlay.  */
3524   if (fun->lo + fun->sec->output_offset + fun->sec->output_section->vma
3525       == info->output_bfd->start_address
3526       || strncmp (fun->sec->output_section->name, ".ovl.init", 9) == 0)
3527     {
3528       fun->sec->linker_mark = 0;
3529       if (fun->rodata != NULL)
3530         fun->rodata->linker_mark = 0;
3531     }
3532   return TRUE;
3533 }
3534
3535 /* If non-zero then unmark functions called from those within sections
3536    that we need to unmark.  Unfortunately this isn't reliable since the
3537    call graph cannot know the destination of function pointer calls.  */
3538 #define RECURSE_UNMARK 0
3539
3540 struct _uos_param {
3541   asection *exclude_input_section;
3542   asection *exclude_output_section;
3543   unsigned long clearing;
3544 };
3545
3546 /* Undo some of mark_overlay_section's work.  */
3547
3548 static bfd_boolean
3549 unmark_overlay_section (struct function_info *fun,
3550                         struct bfd_link_info *info,
3551                         void *param)
3552 {
3553   struct call_info *call;
3554   struct _uos_param *uos_param = param;
3555   unsigned int excluded = 0;
3556
3557   if (fun->visit5)
3558     return TRUE;
3559
3560   fun->visit5 = TRUE;
3561
3562   excluded = 0;
3563   if (fun->sec == uos_param->exclude_input_section
3564       || fun->sec->output_section == uos_param->exclude_output_section)
3565     excluded = 1;
3566
3567   if (RECURSE_UNMARK)
3568     uos_param->clearing += excluded;
3569
3570   if (RECURSE_UNMARK ? uos_param->clearing : excluded)
3571     {
3572       fun->sec->linker_mark = 0;
3573       if (fun->rodata)
3574         fun->rodata->linker_mark = 0;
3575     }
3576
3577   for (call = fun->call_list; call != NULL; call = call->next)
3578     if (!unmark_overlay_section (call->fun, info, param))
3579       return FALSE;
3580
3581   if (RECURSE_UNMARK)
3582     uos_param->clearing -= excluded;
3583   return TRUE;
3584 }
3585
3586 struct _cl_param {
3587   unsigned int lib_size;
3588   asection **lib_sections;
3589 };
3590
3591 /* Add sections we have marked as belonging to overlays to an array
3592    for consideration as non-overlay sections.  The array consist of
3593    pairs of sections, (text,rodata), for functions in the call graph.  */
3594
3595 static bfd_boolean
3596 collect_lib_sections (struct function_info *fun,
3597                       struct bfd_link_info *info,
3598                       void *param)
3599 {
3600   struct _cl_param *lib_param = param;
3601   struct call_info *call;
3602   unsigned int size;
3603
3604   if (fun->visit6)
3605     return TRUE;
3606
3607   fun->visit6 = TRUE;
3608   if (!fun->sec->linker_mark || !fun->sec->gc_mark || fun->sec->segment_mark)
3609     return TRUE;
3610
3611   size = fun->sec->size;
3612   if (fun->rodata)
3613     size += fun->rodata->size;
3614
3615   if (size <= lib_param->lib_size)
3616     {
3617       *lib_param->lib_sections++ = fun->sec;
3618       fun->sec->gc_mark = 0;
3619       if (fun->rodata && fun->rodata->linker_mark && fun->rodata->gc_mark)
3620         {
3621           *lib_param->lib_sections++ = fun->rodata;
3622           fun->rodata->gc_mark = 0;
3623         }
3624       else
3625         *lib_param->lib_sections++ = NULL;
3626     }
3627
3628   for (call = fun->call_list; call != NULL; call = call->next)
3629     collect_lib_sections (call->fun, info, param);
3630
3631   return TRUE;
3632 }
3633
3634 /* qsort predicate to sort sections by call count.  */
3635
3636 static int
3637 sort_lib (const void *a, const void *b)
3638 {
3639   asection *const *s1 = a;
3640   asection *const *s2 = b;
3641   struct _spu_elf_section_data *sec_data;
3642   struct spu_elf_stack_info *sinfo;
3643   int delta;
3644
3645   delta = 0;
3646   if ((sec_data = spu_elf_section_data (*s1)) != NULL
3647       && (sinfo = sec_data->u.i.stack_info) != NULL)
3648     {
3649       int i;
3650       for (i = 0; i < sinfo->num_fun; ++i)
3651         delta -= sinfo->fun[i].call_count;
3652     }
3653
3654   if ((sec_data = spu_elf_section_data (*s2)) != NULL
3655       && (sinfo = sec_data->u.i.stack_info) != NULL)
3656     {
3657       int i;
3658       for (i = 0; i < sinfo->num_fun; ++i)
3659         delta += sinfo->fun[i].call_count;
3660     }
3661
3662   if (delta != 0)
3663     return delta;
3664
3665   return s1 - s2;
3666 }
3667
3668 /* Remove some sections from those marked to be in overlays.  Choose
3669    those that are called from many places, likely library functions.  */
3670
3671 static unsigned int
3672 auto_ovl_lib_functions (struct bfd_link_info *info, unsigned int lib_size)
3673 {
3674   bfd *ibfd;
3675   asection **lib_sections;
3676   unsigned int i, lib_count;
3677   struct _cl_param collect_lib_param;
3678   struct function_info dummy_caller;
3679   struct spu_link_hash_table *htab;
3680
3681   memset (&dummy_caller, 0, sizeof (dummy_caller));
3682   lib_count = 0;
3683   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
3684     {
3685       extern const bfd_target bfd_elf32_spu_vec;
3686       asection *sec;
3687
3688       if (ibfd->xvec != &bfd_elf32_spu_vec)
3689         continue;
3690
3691       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
3692         if (sec->linker_mark
3693             && sec->size < lib_size
3694             && (sec->flags & SEC_CODE) != 0)
3695           lib_count += 1;
3696     }
3697   lib_sections = bfd_malloc (lib_count * 2 * sizeof (*lib_sections));
3698   if (lib_sections == NULL)
3699     return (unsigned int) -1;
3700   collect_lib_param.lib_size = lib_size;
3701   collect_lib_param.lib_sections = lib_sections;
3702   if (!for_each_node (collect_lib_sections, info, &collect_lib_param,
3703                       TRUE))
3704     return (unsigned int) -1;
3705   lib_count = (collect_lib_param.lib_sections - lib_sections) / 2;
3706
3707   /* Sort sections so that those with the most calls are first.  */
3708   if (lib_count > 1)
3709     qsort (lib_sections, lib_count, 2 * sizeof (*lib_sections), sort_lib);
3710
3711   htab = spu_hash_table (info);
3712   for (i = 0; i < lib_count; i++)
3713     {
3714       unsigned int tmp, stub_size;
3715       asection *sec;
3716       struct _spu_elf_section_data *sec_data;
3717       struct spu_elf_stack_info *sinfo;
3718
3719       sec = lib_sections[2 * i];
3720       /* If this section is OK, its size must be less than lib_size.  */
3721       tmp = sec->size;
3722       /* If it has a rodata section, then add that too.  */
3723       if (lib_sections[2 * i + 1])
3724         tmp += lib_sections[2 * i + 1]->size;
3725       /* Add any new overlay call stubs needed by the section.  */
3726       stub_size = 0;
3727       if (tmp < lib_size
3728           && (sec_data = spu_elf_section_data (sec)) != NULL
3729           && (sinfo = sec_data->u.i.stack_info) != NULL)
3730         {
3731           int k;
3732           struct call_info *call;
3733
3734           for (k = 0; k < sinfo->num_fun; ++k)
3735             for (call = sinfo->fun[k].call_list; call; call = call->next)
3736               if (call->fun->sec->linker_mark)
3737                 {
3738                   struct call_info *p;
3739                   for (p = dummy_caller.call_list; p; p = p->next)
3740                     if (p->fun == call->fun)
3741                       break;
3742                   if (!p)
3743                     stub_size += ovl_stub_size (htab->params);
3744                 }
3745         }
3746       if (tmp + stub_size < lib_size)
3747         {
3748           struct call_info **pp, *p;
3749
3750           /* This section fits.  Mark it as non-overlay.  */
3751           lib_sections[2 * i]->linker_mark = 0;
3752           if (lib_sections[2 * i + 1])
3753             lib_sections[2 * i + 1]->linker_mark = 0;
3754           lib_size -= tmp + stub_size;
3755           /* Call stubs to the section we just added are no longer
3756              needed.  */
3757           pp = &dummy_caller.call_list;
3758           while ((p = *pp) != NULL)
3759             if (!p->fun->sec->linker_mark)
3760               {
3761                 lib_size += ovl_stub_size (htab->params);
3762                 *pp = p->next;
3763                 free (p);
3764               }
3765             else
3766               pp = &p->next;
3767           /* Add new call stubs to dummy_caller.  */
3768           if ((sec_data = spu_elf_section_data (sec)) != NULL
3769               && (sinfo = sec_data->u.i.stack_info) != NULL)
3770             {
3771               int k;
3772               struct call_info *call;
3773
3774               for (k = 0; k < sinfo->num_fun; ++k)
3775                 for (call = sinfo->fun[k].call_list;
3776                      call;
3777                      call = call->next)
3778                   if (call->fun->sec->linker_mark)
3779                     {
3780                       struct call_info *callee;
3781                       callee = bfd_malloc (sizeof (*callee));
3782                       if (callee == NULL)
3783                         return (unsigned int) -1;
3784                       *callee = *call;
3785                       if (!insert_callee (&dummy_caller, callee))
3786                         free (callee);
3787                     }
3788             }
3789         }
3790     }
3791   while (dummy_caller.call_list != NULL)
3792     {
3793       struct call_info *call = dummy_caller.call_list;
3794       dummy_caller.call_list = call->next;
3795       free (call);
3796     }
3797   for (i = 0; i < 2 * lib_count; i++)
3798     if (lib_sections[i])
3799       lib_sections[i]->gc_mark = 1;
3800   free (lib_sections);
3801   return lib_size;
3802 }
3803
3804 /* Build an array of overlay sections.  The deepest node's section is
3805    added first, then its parent node's section, then everything called
3806    from the parent section.  The idea being to group sections to
3807    minimise calls between different overlays.  */
3808
3809 static bfd_boolean
3810 collect_overlays (struct function_info *fun,
3811                   struct bfd_link_info *info,
3812                   void *param)
3813 {
3814   struct call_info *call;
3815   bfd_boolean added_fun;
3816   asection ***ovly_sections = param;
3817
3818   if (fun->visit7)
3819     return TRUE;
3820
3821   fun->visit7 = TRUE;
3822   for (call = fun->call_list; call != NULL; call = call->next)
3823     if (!call->is_pasted)
3824       {
3825         if (!collect_overlays (call->fun, info, ovly_sections))
3826           return FALSE;
3827         break;
3828       }
3829
3830   added_fun = FALSE;
3831   if (fun->sec->linker_mark && fun->sec->gc_mark)
3832     {
3833       fun->sec->gc_mark = 0;
3834       *(*ovly_sections)++ = fun->sec;
3835       if (fun->rodata && fun->rodata->linker_mark && fun->rodata->gc_mark)
3836         {
3837           fun->rodata->gc_mark = 0;
3838           *(*ovly_sections)++ = fun->rodata;
3839         }
3840       else
3841         *(*ovly_sections)++ = NULL;
3842       added_fun = TRUE;
3843
3844       /* Pasted sections must stay with the first section.  We don't
3845          put pasted sections in the array, just the first section.
3846          Mark subsequent sections as already considered.  */
3847       if (fun->sec->segment_mark)
3848         {
3849           struct function_info *call_fun = fun;
3850           do
3851             {
3852               for (call = call_fun->call_list; call != NULL; call = call->next)
3853                 if (call->is_pasted)
3854                   {
3855                     call_fun = call->fun;
3856                     call_fun->sec->gc_mark = 0;
3857                     if (call_fun->rodata)
3858                       call_fun->rodata->gc_mark = 0;
3859                     break;
3860                   }
3861               if (call == NULL)
3862                 abort ();
3863             }
3864           while (call_fun->sec->segment_mark);
3865         }
3866     }
3867
3868   for (call = fun->call_list; call != NULL; call = call->next)
3869     if (!collect_overlays (call->fun, info, ovly_sections))
3870       return FALSE;
3871
3872   if (added_fun)
3873     {
3874       struct _spu_elf_section_data *sec_data;
3875       struct spu_elf_stack_info *sinfo;
3876
3877       if ((sec_data = spu_elf_section_data (fun->sec)) != NULL
3878           && (sinfo = sec_data->u.i.stack_info) != NULL)
3879         {
3880           int i;
3881           for (i = 0; i < sinfo->num_fun; ++i)
3882             if (!collect_overlays (&sinfo->fun[i], info, ovly_sections))
3883               return FALSE;
3884         }
3885     }
3886
3887   return TRUE;
3888 }
3889
3890 struct _sum_stack_param {
3891   size_t cum_stack;
3892   size_t overall_stack;
3893   bfd_boolean emit_stack_syms;
3894 };
3895
3896 /* Descend the call graph for FUN, accumulating total stack required.  */
3897
3898 static bfd_boolean
3899 sum_stack (struct function_info *fun,
3900            struct bfd_link_info *info,
3901            void *param)
3902 {
3903   struct call_info *call;
3904   struct function_info *max;
3905   size_t stack, cum_stack;
3906   const char *f1;
3907   bfd_boolean has_call;
3908   struct _sum_stack_param *sum_stack_param = param;
3909   struct spu_link_hash_table *htab;
3910
3911   cum_stack = fun->stack;
3912   sum_stack_param->cum_stack = cum_stack;
3913   if (fun->visit3)
3914     return TRUE;
3915
3916   has_call = FALSE;
3917   max = NULL;
3918   for (call = fun->call_list; call; call = call->next)
3919     {
3920       if (!call->is_pasted)
3921         has_call = TRUE;
3922       if (!sum_stack (call->fun, info, sum_stack_param))
3923         return FALSE;
3924       stack = sum_stack_param->cum_stack;
3925       /* Include caller stack for normal calls, don't do so for
3926          tail calls.  fun->stack here is local stack usage for
3927          this function.  */
3928       if (!call->is_tail || call->is_pasted || call->fun->start != NULL)
3929         stack += fun->stack;
3930       if (cum_stack < stack)
3931         {
3932           cum_stack = stack;
3933           max = call->fun;
3934         }
3935     }
3936
3937   sum_stack_param->cum_stack = cum_stack;
3938   stack = fun->stack;
3939   /* Now fun->stack holds cumulative stack.  */
3940   fun->stack = cum_stack;
3941   fun->visit3 = TRUE;
3942
3943   if (!fun->non_root
3944       && sum_stack_param->overall_stack < cum_stack)
3945     sum_stack_param->overall_stack = cum_stack;
3946
3947   htab = spu_hash_table (info);
3948   if (htab->params->auto_overlay)
3949     return TRUE;
3950
3951   f1 = func_name (fun);
3952   if (htab->params->stack_analysis)
3953     {
3954       if (!fun->non_root)
3955         info->callbacks->info (_("  %s: 0x%v\n"), f1, (bfd_vma) cum_stack);
3956       info->callbacks->minfo (_("%s: 0x%v 0x%v\n"),
3957                               f1, (bfd_vma) stack, (bfd_vma) cum_stack);
3958
3959       if (has_call)
3960         {
3961           info->callbacks->minfo (_("  calls:\n"));
3962           for (call = fun->call_list; call; call = call->next)
3963             if (!call->is_pasted)
3964               {
3965                 const char *f2 = func_name (call->fun);
3966                 const char *ann1 = call->fun == max ? "*" : " ";
3967                 const char *ann2 = call->is_tail ? "t" : " ";
3968
3969                 info->callbacks->minfo (_("   %s%s %s\n"), ann1, ann2, f2);
3970               }
3971         }
3972     }
3973
3974   if (sum_stack_param->emit_stack_syms)
3975     {
3976       char *name = bfd_malloc (18 + strlen (f1));
3977       struct elf_link_hash_entry *h;
3978
3979       if (name == NULL)
3980         return FALSE;
3981
3982       if (fun->global || ELF_ST_BIND (fun->u.sym->st_info) == STB_GLOBAL)
3983         sprintf (name, "__stack_%s", f1);
3984       else
3985         sprintf (name, "__stack_%x_%s", fun->sec->id & 0xffffffff, f1);
3986
3987       h = elf_link_hash_lookup (&htab->elf, name, TRUE, TRUE, FALSE);
3988       free (name);
3989       if (h != NULL
3990           && (h->root.type == bfd_link_hash_new
3991               || h->root.type == bfd_link_hash_undefined
3992               || h->root.type == bfd_link_hash_undefweak))
3993         {
3994           h->root.type = bfd_link_hash_defined;
3995           h->root.u.def.section = bfd_abs_section_ptr;
3996           h->root.u.def.value = cum_stack;
3997           h->size = 0;
3998           h->type = 0;
3999           h->ref_regular = 1;
4000           h->def_regular = 1;
4001           h->ref_regular_nonweak = 1;
4002           h->forced_local = 1;
4003           h->non_elf = 0;
4004         }
4005     }
4006
4007   return TRUE;
4008 }
4009
4010 /* SEC is part of a pasted function.  Return the call_info for the
4011    next section of this function.  */
4012
4013 static struct call_info *
4014 find_pasted_call (asection *sec)
4015 {
4016   struct _spu_elf_section_data *sec_data = spu_elf_section_data (sec);
4017   struct spu_elf_stack_info *sinfo = sec_data->u.i.stack_info;
4018   struct call_info *call;
4019   int k;
4020
4021   for (k = 0; k < sinfo->num_fun; ++k)
4022     for (call = sinfo->fun[k].call_list; call != NULL; call = call->next)
4023       if (call->is_pasted)
4024         return call;
4025   abort ();
4026   return 0;
4027 }
4028
4029 /* qsort predicate to sort bfds by file name.  */
4030
4031 static int
4032 sort_bfds (const void *a, const void *b)
4033 {
4034   bfd *const *abfd1 = a;
4035   bfd *const *abfd2 = b;
4036
4037   return strcmp ((*abfd1)->filename, (*abfd2)->filename);
4038 }
4039
4040 static unsigned int
4041 print_one_overlay_section (FILE *script,
4042                            unsigned int base,
4043                            unsigned int count,
4044                            unsigned int ovlynum,
4045                            unsigned int *ovly_map,
4046                            asection **ovly_sections,
4047                            struct bfd_link_info *info)
4048 {
4049   unsigned int j;
4050
4051   for (j = base; j < count && ovly_map[j] == ovlynum; j++)
4052     {
4053       asection *sec = ovly_sections[2 * j];
4054
4055       if (fprintf (script, "   %s%c%s (%s)\n",
4056                    (sec->owner->my_archive != NULL
4057                     ? sec->owner->my_archive->filename : ""),
4058                    info->path_separator,
4059                    sec->owner->filename,
4060                    sec->name) <= 0)
4061         return -1;
4062       if (sec->segment_mark)
4063         {
4064           struct call_info *call = find_pasted_call (sec);
4065           while (call != NULL)
4066             {
4067               struct function_info *call_fun = call->fun;
4068               sec = call_fun->sec;
4069               if (fprintf (script, "   %s%c%s (%s)\n",
4070                            (sec->owner->my_archive != NULL
4071                             ? sec->owner->my_archive->filename : ""),
4072                            info->path_separator,
4073                            sec->owner->filename,
4074                            sec->name) <= 0)
4075                 return -1;
4076               for (call = call_fun->call_list; call; call = call->next)
4077                 if (call->is_pasted)
4078                   break;
4079             }
4080         }
4081     }
4082
4083   for (j = base; j < count && ovly_map[j] == ovlynum; j++)
4084     {
4085       asection *sec = ovly_sections[2 * j + 1];
4086       if (sec != NULL
4087           && fprintf (script, "   %s%c%s (%s)\n",
4088                       (sec->owner->my_archive != NULL
4089                        ? sec->owner->my_archive->filename : ""),
4090                       info->path_separator,
4091                       sec->owner->filename,
4092                       sec->name) <= 0)
4093         return -1;
4094
4095       sec = ovly_sections[2 * j];
4096       if (sec->segment_mark)
4097         {
4098           struct call_info *call = find_pasted_call (sec);
4099           while (call != NULL)
4100             {
4101               struct function_info *call_fun = call->fun;
4102               sec = call_fun->rodata;
4103               if (sec != NULL
4104                   && fprintf (script, "   %s%c%s (%s)\n",
4105                               (sec->owner->my_archive != NULL
4106                                ? sec->owner->my_archive->filename : ""),
4107                               info->path_separator,
4108                               sec->owner->filename,
4109                               sec->name) <= 0)
4110                 return -1;
4111               for (call = call_fun->call_list; call; call = call->next)
4112                 if (call->is_pasted)
4113                   break;
4114             }
4115         }
4116     }
4117
4118   return j;
4119 }
4120
4121 /* Handle --auto-overlay.  */
4122
4123 static void
4124 spu_elf_auto_overlay (struct bfd_link_info *info)
4125 {
4126   bfd *ibfd;
4127   bfd **bfd_arr;
4128   struct elf_segment_map *m;
4129   unsigned int fixed_size, lo, hi;
4130   struct spu_link_hash_table *htab;
4131   unsigned int base, i, count, bfd_count;
4132   unsigned int region, ovlynum;
4133   asection **ovly_sections, **ovly_p;
4134   unsigned int *ovly_map;
4135   FILE *script;
4136   unsigned int total_overlay_size, overlay_size;
4137   const char *ovly_mgr_entry;
4138   struct elf_link_hash_entry *h;
4139   struct _mos_param mos_param;
4140   struct _uos_param uos_param;
4141   struct function_info dummy_caller;
4142
4143   /* Find the extents of our loadable image.  */
4144   lo = (unsigned int) -1;
4145   hi = 0;
4146   for (m = elf_tdata (info->output_bfd)->segment_map; m != NULL; m = m->next)
4147     if (m->p_type == PT_LOAD)
4148       for (i = 0; i < m->count; i++)
4149         if (m->sections[i]->size != 0)
4150           {
4151             if (m->sections[i]->vma < lo)
4152               lo = m->sections[i]->vma;
4153             if (m->sections[i]->vma + m->sections[i]->size - 1 > hi)
4154               hi = m->sections[i]->vma + m->sections[i]->size - 1;
4155           }
4156   fixed_size = hi + 1 - lo;
4157
4158   if (!discover_functions (info))
4159     goto err_exit;
4160
4161   if (!build_call_tree (info))
4162     goto err_exit;
4163
4164   htab = spu_hash_table (info);
4165   if (htab->reserved == 0)
4166     {
4167       struct _sum_stack_param sum_stack_param;
4168
4169       sum_stack_param.emit_stack_syms = 0;
4170       sum_stack_param.overall_stack = 0;
4171       if (!for_each_node (sum_stack, info, &sum_stack_param, TRUE))
4172         goto err_exit;
4173       htab->reserved = sum_stack_param.overall_stack + htab->extra_stack_space;
4174     }
4175
4176   /* No need for overlays if everything already fits.  */
4177   if (fixed_size + htab->reserved <= htab->local_store
4178       && htab->params->ovly_flavour != ovly_soft_icache)
4179     {
4180       htab->params->auto_overlay = 0;
4181       return;
4182     }
4183
4184   uos_param.exclude_input_section = 0;
4185   uos_param.exclude_output_section
4186     = bfd_get_section_by_name (info->output_bfd, ".interrupt");
4187
4188   ovly_mgr_entry = "__ovly_load";
4189   if (htab->params->ovly_flavour == ovly_soft_icache)
4190     ovly_mgr_entry = "__icache_br_handler";
4191   h = elf_link_hash_lookup (&htab->elf, ovly_mgr_entry,
4192                             FALSE, FALSE, FALSE);
4193   if (h != NULL
4194       && (h->root.type == bfd_link_hash_defined
4195           || h->root.type == bfd_link_hash_defweak)
4196       && h->def_regular)
4197     {
4198       /* We have a user supplied overlay manager.  */
4199       uos_param.exclude_input_section = h->root.u.def.section;
4200     }
4201   else
4202     {
4203       /* If no user overlay manager, spu_elf_load_ovl_mgr will add our
4204          builtin version to .text, and will adjust .text size.  */
4205       fixed_size += (*htab->params->spu_elf_load_ovl_mgr) ();
4206     }
4207
4208   /* Mark overlay sections, and find max overlay section size.  */
4209   mos_param.max_overlay_size = 0;
4210   if (!for_each_node (mark_overlay_section, info, &mos_param, TRUE))
4211     goto err_exit;
4212
4213   /* We can't put the overlay manager or interrupt routines in
4214      overlays.  */
4215   uos_param.clearing = 0;
4216   if ((uos_param.exclude_input_section
4217        || uos_param.exclude_output_section)
4218       && !for_each_node (unmark_overlay_section, info, &uos_param, TRUE))
4219     goto err_exit;
4220
4221   bfd_count = 0;
4222   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
4223     ++bfd_count;
4224   bfd_arr = bfd_malloc (bfd_count * sizeof (*bfd_arr));
4225   if (bfd_arr == NULL)
4226     goto err_exit;
4227
4228   /* Count overlay sections, and subtract their sizes from "fixed_size".  */
4229   count = 0;
4230   bfd_count = 0;
4231   total_overlay_size = 0;
4232   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
4233     {
4234       extern const bfd_target bfd_elf32_spu_vec;
4235       asection *sec;
4236       unsigned int old_count;
4237
4238       if (ibfd->xvec != &bfd_elf32_spu_vec)
4239         continue;
4240
4241       old_count = count;
4242       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
4243         if (sec->linker_mark)
4244           {
4245             if ((sec->flags & SEC_CODE) != 0)
4246               count += 1;
4247             fixed_size -= sec->size;
4248             total_overlay_size += sec->size;
4249           }
4250         else if ((sec->flags & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD)
4251                  && sec->output_section->owner == info->output_bfd
4252                  && strncmp (sec->output_section->name, ".ovl.init", 9) == 0)
4253           fixed_size -= sec->size;
4254       if (count != old_count)
4255         bfd_arr[bfd_count++] = ibfd;
4256     }
4257
4258   /* Since the overlay link script selects sections by file name and
4259      section name, ensure that file names are unique.  */
4260   if (bfd_count > 1)
4261     {
4262       bfd_boolean ok = TRUE;
4263
4264       qsort (bfd_arr, bfd_count, sizeof (*bfd_arr), sort_bfds);
4265       for (i = 1; i < bfd_count; ++i)
4266         if (strcmp (bfd_arr[i - 1]->filename, bfd_arr[i]->filename) == 0)
4267           {
4268             if (bfd_arr[i - 1]->my_archive == bfd_arr[i]->my_archive)
4269               {
4270                 if (bfd_arr[i - 1]->my_archive && bfd_arr[i]->my_archive)
4271                   info->callbacks->einfo (_("%s duplicated in %s\n"),
4272                                           bfd_arr[i]->filename,
4273                                           bfd_arr[i]->my_archive->filename);
4274                 else
4275                   info->callbacks->einfo (_("%s duplicated\n"),
4276                                           bfd_arr[i]->filename);
4277                 ok = FALSE;
4278               }
4279           }
4280       if (!ok)
4281         {
4282           info->callbacks->einfo (_("sorry, no support for duplicate "
4283                                     "object files in auto-overlay script\n"));
4284           bfd_set_error (bfd_error_bad_value);
4285           goto err_exit;
4286         }
4287     }
4288   free (bfd_arr);
4289
4290   fixed_size += htab->reserved;
4291   fixed_size += htab->non_ovly_stub * ovl_stub_size (htab->params);
4292   if (fixed_size + mos_param.max_overlay_size <= htab->local_store)
4293     {
4294       if (htab->params->ovly_flavour == ovly_soft_icache)
4295         {
4296           /* Stubs in the non-icache area are bigger.  */
4297           fixed_size += htab->non_ovly_stub * 16;
4298           /* Space for icache manager tables.
4299              a) Tag array, one quadword per cache line.
4300              - word 0: ia address of present line, init to zero.  */
4301           fixed_size += 16 << htab->num_lines_log2;
4302           /* b) Rewrite "to" list, one quadword per cache line.  */
4303           fixed_size += 16 << htab->num_lines_log2;
4304           /* c) Rewrite "from" list, one byte per outgoing branch (rounded up
4305                 to a power-of-two number of full quadwords) per cache line.  */
4306           fixed_size += 16 << (htab->fromelem_size_log2
4307                                + htab->num_lines_log2);
4308           /* d) Pointer to __ea backing store (toe), 1 quadword.  */
4309           fixed_size += 16;
4310         }
4311       else
4312         {
4313           /* Guess number of overlays.  Assuming overlay buffer is on
4314              average only half full should be conservative.  */
4315           ovlynum = (total_overlay_size * 2 * htab->params->num_lines
4316                      / (htab->local_store - fixed_size));
4317           /* Space for _ovly_table[], _ovly_buf_table[] and toe.  */
4318           fixed_size += ovlynum * 16 + 16 + 4 + 16;
4319         }
4320     }
4321
4322   if (fixed_size + mos_param.max_overlay_size > htab->local_store)
4323     info->callbacks->einfo (_("non-overlay size of 0x%v plus maximum overlay "
4324                               "size of 0x%v exceeds local store\n"),
4325                             (bfd_vma) fixed_size,
4326                             (bfd_vma) mos_param.max_overlay_size);
4327
4328   /* Now see if we should put some functions in the non-overlay area.  */
4329   else if (fixed_size < htab->overlay_fixed)
4330     {
4331       unsigned int max_fixed, lib_size;
4332
4333       max_fixed = htab->local_store - mos_param.max_overlay_size;
4334       if (max_fixed > htab->overlay_fixed)
4335         max_fixed = htab->overlay_fixed;
4336       lib_size = max_fixed - fixed_size;
4337       lib_size = auto_ovl_lib_functions (info, lib_size);
4338       if (lib_size == (unsigned int) -1)
4339         goto err_exit;
4340       fixed_size = max_fixed - lib_size;
4341     }
4342
4343   /* Build an array of sections, suitably sorted to place into
4344      overlays.  */
4345   ovly_sections = bfd_malloc (2 * count * sizeof (*ovly_sections));
4346   if (ovly_sections == NULL)
4347     goto err_exit;
4348   ovly_p = ovly_sections;
4349   if (!for_each_node (collect_overlays, info, &ovly_p, TRUE))
4350     goto err_exit;
4351   count = (size_t) (ovly_p - ovly_sections) / 2;
4352   ovly_map = bfd_malloc (count * sizeof (*ovly_map));
4353   if (ovly_map == NULL)
4354     goto err_exit;
4355
4356   memset (&dummy_caller, 0, sizeof (dummy_caller));
4357   overlay_size = (htab->local_store - fixed_size) / htab->params->num_lines;
4358   if (htab->params->line_size != 0)
4359     overlay_size = htab->params->line_size;
4360   base = 0;
4361   ovlynum = 0;
4362   while (base < count)
4363     {
4364       unsigned int size = 0;
4365
4366       for (i = base; i < count; i++)
4367         {
4368           asection *sec;
4369           unsigned int tmp;
4370           unsigned int num_stubs;
4371           struct call_info *call, *pasty;
4372           struct _spu_elf_section_data *sec_data;
4373           struct spu_elf_stack_info *sinfo;
4374           int k;
4375
4376           /* See whether we can add this section to the current
4377              overlay without overflowing our overlay buffer.  */
4378           sec = ovly_sections[2 * i];
4379           tmp = size + sec->size;
4380           if (ovly_sections[2 * i + 1])
4381             tmp += ovly_sections[2 * i + 1]->size;
4382           if (tmp > overlay_size)
4383             break;
4384           if (sec->segment_mark)
4385             {
4386               /* Pasted sections must stay together, so add their
4387                  sizes too.  */
4388               struct call_info *pasty = find_pasted_call (sec);
4389               while (pasty != NULL)
4390                 {
4391                   struct function_info *call_fun = pasty->fun;
4392                   tmp += call_fun->sec->size;
4393                   if (call_fun->rodata)
4394                     tmp += call_fun->rodata->size;
4395                   for (pasty = call_fun->call_list; pasty; pasty = pasty->next)
4396                     if (pasty->is_pasted)
4397                       break;
4398                 }
4399             }
4400           if (tmp > overlay_size)
4401             break;
4402
4403           /* If we add this section, we might need new overlay call
4404              stubs.  Add any overlay section calls to dummy_call.  */
4405           pasty = NULL;
4406           sec_data = spu_elf_section_data (sec);
4407           sinfo = sec_data->u.i.stack_info;
4408           for (k = 0; k < sinfo->num_fun; ++k)
4409             for (call = sinfo->fun[k].call_list; call; call = call->next)
4410               if (call->is_pasted)
4411                 {
4412                   BFD_ASSERT (pasty == NULL);
4413                   pasty = call;
4414                 }
4415               else if (call->fun->sec->linker_mark)
4416                 {
4417                   if (!copy_callee (&dummy_caller, call))
4418                     goto err_exit;
4419                 }
4420           while (pasty != NULL)
4421             {
4422               struct function_info *call_fun = pasty->fun;
4423               pasty = NULL;
4424               for (call = call_fun->call_list; call; call = call->next)
4425                 if (call->is_pasted)
4426                   {
4427                     BFD_ASSERT (pasty == NULL);
4428                     pasty = call;
4429                   }
4430                 else if (!copy_callee (&dummy_caller, call))
4431                   goto err_exit;
4432             }
4433
4434           /* Calculate call stub size.  */
4435           num_stubs = 0;
4436           for (call = dummy_caller.call_list; call; call = call->next)
4437             {
4438               unsigned int k;
4439
4440               ++num_stubs;
4441               /* If the call is within this overlay, we won't need a
4442                  stub.  */
4443               for (k = base; k < i + 1; k++)
4444                 if (call->fun->sec == ovly_sections[2 * k])
4445                   {
4446                     --num_stubs;
4447                     break;
4448                   }
4449             }
4450           if (htab->params->ovly_flavour == ovly_soft_icache
4451               && num_stubs > htab->params->max_branch)
4452             break;
4453           if (tmp + num_stubs * ovl_stub_size (htab->params)
4454               > overlay_size)
4455             break;
4456           size = tmp;
4457         }
4458
4459       if (i == base)
4460         {
4461           info->callbacks->einfo (_("%B:%A%s exceeds overlay size\n"),
4462                                   ovly_sections[2 * i]->owner,
4463                                   ovly_sections[2 * i],
4464                                   ovly_sections[2 * i + 1] ? " + rodata" : "");
4465           bfd_set_error (bfd_error_bad_value);
4466           goto err_exit;
4467         }
4468
4469       while (dummy_caller.call_list != NULL)
4470         {
4471           struct call_info *call = dummy_caller.call_list;
4472           dummy_caller.call_list = call->next;
4473           free (call);
4474         }
4475
4476       ++ovlynum;
4477       while (base < i)
4478         ovly_map[base++] = ovlynum;
4479     }
4480
4481   script = htab->params->spu_elf_open_overlay_script ();
4482
4483   if (fprintf (script, "SECTIONS\n{\n") <= 0)
4484     goto file_err;
4485
4486   if (htab->params->ovly_flavour == ovly_soft_icache)
4487     {
4488       if (fprintf (script,
4489                    " .data.icache ALIGN (16) : { *(.ovtab) *(.data.icache) }\n"
4490                    " . = ALIGN (%u);\n"
4491                    " .ovl.init : { *(.ovl.init) }\n"
4492                    " . = ABSOLUTE (ADDR (.ovl.init));\n",
4493                    htab->params->line_size) <= 0)
4494         goto file_err;
4495
4496       base = 0;
4497       ovlynum = 1;
4498       while (base < count)
4499         {
4500           unsigned int indx = ovlynum - 1;
4501           unsigned int vma, lma;
4502
4503           vma = (indx & (htab->params->num_lines - 1)) << htab->line_size_log2;
4504           lma = indx << htab->line_size_log2;
4505
4506           if (fprintf (script, " .ovly%u ABSOLUTE (ADDR (.ovl.init)) + %u "
4507                        ": AT (ALIGN (LOADADDR (.ovl.init) + SIZEOF (.ovl.init), 16) + %u) {\n",
4508                        ovlynum, vma, lma) <= 0)
4509             goto file_err;
4510
4511           base = print_one_overlay_section (script, base, count, ovlynum,
4512                                             ovly_map, ovly_sections, info);
4513           if (base == (unsigned) -1)
4514             goto file_err;
4515
4516           if (fprintf (script, "  }\n") <= 0)
4517             goto file_err;
4518
4519           ovlynum++;
4520         }
4521
4522       if (fprintf (script, " . = ABSOLUTE (ADDR (.ovl.init)) + %u;\n",
4523                    1 << (htab->num_lines_log2 + htab->line_size_log2)) <= 0)
4524         goto file_err;
4525     }
4526   else
4527     {
4528       if (fprintf (script,
4529                    " . = ALIGN (16);\n"
4530                    " .ovl.init : { *(.ovl.init) }\n"
4531                    " . = ABSOLUTE (ADDR (.ovl.init));\n") <= 0)
4532         goto file_err;
4533
4534       for (region = 1; region <= htab->params->num_lines; region++)
4535         {
4536           ovlynum = region;
4537           base = 0;
4538           while (base < count && ovly_map[base] < ovlynum)
4539             base++;
4540
4541           if (base == count)
4542             break;
4543
4544           if (region == 1)
4545             {
4546               /* We need to set lma since we are overlaying .ovl.init.  */
4547               if (fprintf (script,
4548                            " OVERLAY : AT (ALIGN (LOADADDR (.ovl.init) + SIZEOF (.ovl.init), 16))\n {\n") <= 0)
4549                 goto file_err;
4550             }
4551           else
4552             {
4553               if (fprintf (script, " OVERLAY :\n {\n") <= 0)
4554                 goto file_err;
4555             }
4556
4557           while (base < count)
4558             {
4559               if (fprintf (script, "  .ovly%u {\n", ovlynum) <= 0)
4560                 goto file_err;
4561
4562               base = print_one_overlay_section (script, base, count, ovlynum,
4563                                                 ovly_map, ovly_sections, info);
4564               if (base == (unsigned) -1)
4565                 goto file_err;
4566
4567               if (fprintf (script, "  }\n") <= 0)
4568                 goto file_err;
4569
4570               ovlynum += htab->params->num_lines;
4571               while (base < count && ovly_map[base] < ovlynum)
4572                 base++;
4573             }
4574
4575           if (fprintf (script, " }\n") <= 0)
4576             goto file_err;
4577         }
4578
4579     }
4580
4581   free (ovly_map);
4582   free (ovly_sections);
4583
4584   if (fprintf (script, "}\nINSERT BEFORE .text;\n") <= 0)
4585     goto file_err;
4586   if (fclose (script) != 0)
4587     goto file_err;
4588
4589   if (htab->params->auto_overlay & AUTO_RELINK)
4590     (*htab->params->spu_elf_relink) ();
4591
4592   xexit (0);
4593
4594  file_err:
4595   bfd_set_error (bfd_error_system_call);
4596  err_exit:
4597   info->callbacks->einfo ("%F%P: auto overlay error: %E\n");
4598   xexit (1);
4599 }
4600
4601 /* Provide an estimate of total stack required.  */
4602
4603 static bfd_boolean
4604 spu_elf_stack_analysis (struct bfd_link_info *info)
4605 {
4606   struct spu_link_hash_table *htab;
4607   struct _sum_stack_param sum_stack_param;
4608
4609   if (!discover_functions (info))
4610     return FALSE;
4611
4612   if (!build_call_tree (info))
4613     return FALSE;
4614
4615   htab = spu_hash_table (info);
4616   if (htab->params->stack_analysis)
4617     {
4618       info->callbacks->info (_("Stack size for call graph root nodes.\n"));
4619       info->callbacks->minfo (_("\nStack size for functions.  "
4620                                 "Annotations: '*' max stack, 't' tail call\n"));
4621     }
4622
4623   sum_stack_param.emit_stack_syms = htab->params->emit_stack_syms;
4624   sum_stack_param.overall_stack = 0;
4625   if (!for_each_node (sum_stack, info, &sum_stack_param, TRUE))
4626     return FALSE;
4627
4628   if (htab->params->stack_analysis)
4629     info->callbacks->info (_("Maximum stack required is 0x%v\n"),
4630                            (bfd_vma) sum_stack_param.overall_stack);
4631   return TRUE;
4632 }
4633
4634 /* Perform a final link.  */
4635
4636 static bfd_boolean
4637 spu_elf_final_link (bfd *output_bfd, struct bfd_link_info *info)
4638 {
4639   struct spu_link_hash_table *htab = spu_hash_table (info);
4640
4641   if (htab->params->auto_overlay)
4642     spu_elf_auto_overlay (info);
4643
4644   if ((htab->params->stack_analysis
4645        || (htab->params->ovly_flavour == ovly_soft_icache
4646            && htab->params->lrlive_analysis))
4647       && !spu_elf_stack_analysis (info))
4648     info->callbacks->einfo ("%X%P: stack/lrlive analysis error: %E\n");
4649
4650   if (!spu_elf_build_stubs (info))
4651     info->callbacks->einfo ("%F%P: can not build overlay stubs: %E\n");
4652
4653   return bfd_elf_final_link (output_bfd, info);
4654 }
4655
4656 /* Called when not normally emitting relocs, ie. !info->relocatable
4657    and !info->emitrelocations.  Returns a count of special relocs
4658    that need to be emitted.  */
4659
4660 static unsigned int
4661 spu_elf_count_relocs (struct bfd_link_info *info, asection *sec)
4662 {
4663   Elf_Internal_Rela *relocs;
4664   unsigned int count = 0;
4665
4666   relocs = _bfd_elf_link_read_relocs (sec->owner, sec, NULL, NULL,
4667                                       info->keep_memory);
4668   if (relocs != NULL)
4669     {
4670       Elf_Internal_Rela *rel;
4671       Elf_Internal_Rela *relend = relocs + sec->reloc_count;
4672
4673       for (rel = relocs; rel < relend; rel++)
4674         {
4675           int r_type = ELF32_R_TYPE (rel->r_info);
4676           if (r_type == R_SPU_PPU32 || r_type == R_SPU_PPU64)
4677             ++count;
4678         }
4679
4680       if (elf_section_data (sec)->relocs != relocs)
4681         free (relocs);
4682     }
4683
4684   return count;
4685 }
4686
4687 /* Apply RELOCS to CONTENTS of INPUT_SECTION from INPUT_BFD.  */
4688
4689 static int
4690 spu_elf_relocate_section (bfd *output_bfd,
4691                           struct bfd_link_info *info,
4692                           bfd *input_bfd,
4693                           asection *input_section,
4694                           bfd_byte *contents,
4695                           Elf_Internal_Rela *relocs,
4696                           Elf_Internal_Sym *local_syms,
4697                           asection **local_sections)
4698 {
4699   Elf_Internal_Shdr *symtab_hdr;
4700   struct elf_link_hash_entry **sym_hashes;
4701   Elf_Internal_Rela *rel, *relend;
4702   struct spu_link_hash_table *htab;
4703   asection *ea;
4704   int ret = TRUE;
4705   bfd_boolean emit_these_relocs = FALSE;
4706   bfd_boolean is_ea_sym;
4707   bfd_boolean stubs;
4708   unsigned int iovl = 0;
4709
4710   htab = spu_hash_table (info);
4711   stubs = (htab->stub_sec != NULL
4712            && maybe_needs_stubs (input_section));
4713   iovl = overlay_index (input_section);
4714   ea = bfd_get_section_by_name (output_bfd, "._ea");
4715   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
4716   sym_hashes = (struct elf_link_hash_entry **) (elf_sym_hashes (input_bfd));
4717
4718   rel = relocs;
4719   relend = relocs + input_section->reloc_count;
4720   for (; rel < relend; rel++)
4721     {
4722       int r_type;
4723       reloc_howto_type *howto;
4724       unsigned int r_symndx;
4725       Elf_Internal_Sym *sym;
4726       asection *sec;
4727       struct elf_link_hash_entry *h;
4728       const char *sym_name;
4729       bfd_vma relocation;
4730       bfd_vma addend;
4731       bfd_reloc_status_type r;
4732       bfd_boolean unresolved_reloc;
4733       bfd_boolean warned;
4734       enum _stub_type stub_type;
4735
4736       r_symndx = ELF32_R_SYM (rel->r_info);
4737       r_type = ELF32_R_TYPE (rel->r_info);
4738       howto = elf_howto_table + r_type;
4739       unresolved_reloc = FALSE;
4740       warned = FALSE;
4741       h = NULL;
4742       sym = NULL;
4743       sec = NULL;
4744       if (r_symndx < symtab_hdr->sh_info)
4745         {
4746           sym = local_syms + r_symndx;
4747           sec = local_sections[r_symndx];
4748           sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
4749           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
4750         }
4751       else
4752         {
4753           if (sym_hashes == NULL)
4754             return FALSE;
4755
4756           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4757
4758           while (h->root.type == bfd_link_hash_indirect
4759                  || h->root.type == bfd_link_hash_warning)
4760             h = (struct elf_link_hash_entry *) h->root.u.i.link;
4761
4762           relocation = 0;
4763           if (h->root.type == bfd_link_hash_defined
4764               || h->root.type == bfd_link_hash_defweak)
4765             {
4766               sec = h->root.u.def.section;
4767               if (sec == NULL
4768                   || sec->output_section == NULL)
4769                 /* Set a flag that will be cleared later if we find a
4770                    relocation value for this symbol.  output_section
4771                    is typically NULL for symbols satisfied by a shared
4772                    library.  */
4773                 unresolved_reloc = TRUE;
4774               else
4775                 relocation = (h->root.u.def.value
4776                               + sec->output_section->vma
4777                               + sec->output_offset);
4778             }
4779           else if (h->root.type == bfd_link_hash_undefweak)
4780             ;
4781           else if (info->unresolved_syms_in_objects == RM_IGNORE
4782                    && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
4783             ;
4784           else if (!info->relocatable
4785                    && !(r_type == R_SPU_PPU32 || r_type == R_SPU_PPU64))
4786             {
4787               bfd_boolean err;
4788               err = (info->unresolved_syms_in_objects == RM_GENERATE_ERROR
4789                      || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT);
4790               if (!info->callbacks->undefined_symbol (info,
4791                                                       h->root.root.string,
4792                                                       input_bfd,
4793                                                       input_section,
4794                                                       rel->r_offset, err))
4795                 return FALSE;
4796               warned = TRUE;
4797             }
4798           sym_name = h->root.root.string;
4799         }
4800
4801       if (sec != NULL && elf_discarded_section (sec))
4802         {
4803           /* For relocs against symbols from removed linkonce sections,
4804              or sections discarded by a linker script, we just want the
4805              section contents zeroed.  Avoid any special processing.  */
4806           _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
4807           rel->r_info = 0;
4808           rel->r_addend = 0;
4809           continue;
4810         }
4811
4812       if (info->relocatable)
4813         continue;
4814
4815       is_ea_sym = (ea != NULL
4816                    && sec != NULL
4817                    && sec->output_section == ea);
4818
4819       /* If this symbol is in an overlay area, we may need to relocate
4820          to the overlay stub.  */
4821       addend = rel->r_addend;
4822       if (stubs
4823           && !is_ea_sym
4824           && (stub_type = needs_ovl_stub (h, sym, sec, input_section, rel,
4825                                           contents, info)) != no_stub)
4826         {
4827           unsigned int ovl = 0;
4828           struct got_entry *g, **head;
4829
4830           if (stub_type != nonovl_stub)
4831             ovl = iovl;
4832
4833           if (h != NULL)
4834             head = &h->got.glist;
4835           else
4836             head = elf_local_got_ents (input_bfd) + r_symndx;
4837
4838           for (g = *head; g != NULL; g = g->next)
4839             if (htab->params->ovly_flavour == ovly_soft_icache
4840                 ? g->br_addr == (rel->r_offset
4841                                  + input_section->output_offset
4842                                  + input_section->output_section->vma)
4843                 : g->addend == addend && (g->ovl == ovl || g->ovl == 0))
4844               break;
4845           if (g == NULL)
4846             abort ();
4847
4848           relocation = g->stub_addr;
4849           addend = 0;
4850         }
4851       else
4852         {
4853           /* For soft icache, encode the overlay index into addresses.  */
4854           if (htab->params->ovly_flavour == ovly_soft_icache
4855               && (r_type == R_SPU_ADDR16_HI
4856                   || r_type == R_SPU_ADDR32 || r_type == R_SPU_REL32)
4857               && !is_ea_sym)
4858             {
4859               unsigned int ovl = overlay_index (sec);
4860               if (ovl != 0)
4861                 {
4862                   unsigned int set_id = ((ovl - 1) >> htab->num_lines_log2) + 1;
4863                   relocation += set_id << 18;
4864                 }
4865             }
4866         }
4867
4868       if (unresolved_reloc)
4869         ;
4870       else if (r_type == R_SPU_PPU32 || r_type == R_SPU_PPU64)
4871         {
4872           if (is_ea_sym)
4873             {
4874               /* ._ea is a special section that isn't allocated in SPU
4875                  memory, but rather occupies space in PPU memory as
4876                  part of an embedded ELF image.  If this reloc is
4877                  against a symbol defined in ._ea, then transform the
4878                  reloc into an equivalent one without a symbol
4879                  relative to the start of the ELF image.  */
4880               rel->r_addend += (relocation
4881                                 - ea->vma
4882                                 + elf_section_data (ea)->this_hdr.sh_offset);
4883               rel->r_info = ELF32_R_INFO (0, r_type);
4884             }
4885           emit_these_relocs = TRUE;
4886           continue;
4887         }
4888       else if (is_ea_sym)
4889         unresolved_reloc = TRUE;
4890
4891       if (unresolved_reloc)
4892         {
4893           (*_bfd_error_handler)
4894             (_("%B(%s+0x%lx): unresolvable %s relocation against symbol `%s'"),
4895              input_bfd,
4896              bfd_get_section_name (input_bfd, input_section),
4897              (long) rel->r_offset,
4898              howto->name,
4899              sym_name);
4900           ret = FALSE;
4901         }
4902
4903       r = _bfd_final_link_relocate (howto,
4904                                     input_bfd,
4905                                     input_section,
4906                                     contents,
4907                                     rel->r_offset, relocation, addend);
4908
4909       if (r != bfd_reloc_ok)
4910         {
4911           const char *msg = (const char *) 0;
4912
4913           switch (r)
4914             {
4915             case bfd_reloc_overflow:
4916               if (!((*info->callbacks->reloc_overflow)
4917                     (info, (h ? &h->root : NULL), sym_name, howto->name,
4918                      (bfd_vma) 0, input_bfd, input_section, rel->r_offset)))
4919                 return FALSE;
4920               break;
4921
4922             case bfd_reloc_undefined:
4923               if (!((*info->callbacks->undefined_symbol)
4924                     (info, sym_name, input_bfd, input_section,
4925                      rel->r_offset, TRUE)))
4926                 return FALSE;
4927               break;
4928
4929             case bfd_reloc_outofrange:
4930               msg = _("internal error: out of range error");
4931               goto common_error;
4932
4933             case bfd_reloc_notsupported:
4934               msg = _("internal error: unsupported relocation error");
4935               goto common_error;
4936
4937             case bfd_reloc_dangerous:
4938               msg = _("internal error: dangerous error");
4939               goto common_error;
4940
4941             default:
4942               msg = _("internal error: unknown error");
4943               /* fall through */
4944
4945             common_error:
4946               ret = FALSE;
4947               if (!((*info->callbacks->warning)
4948                     (info, msg, sym_name, input_bfd, input_section,
4949                      rel->r_offset)))
4950                 return FALSE;
4951               break;
4952             }
4953         }
4954     }
4955
4956   if (ret
4957       && emit_these_relocs
4958       && !info->emitrelocations)
4959     {
4960       Elf_Internal_Rela *wrel;
4961       Elf_Internal_Shdr *rel_hdr;
4962
4963       wrel = rel = relocs;
4964       relend = relocs + input_section->reloc_count;
4965       for (; rel < relend; rel++)
4966         {
4967           int r_type;
4968
4969           r_type = ELF32_R_TYPE (rel->r_info);
4970           if (r_type == R_SPU_PPU32 || r_type == R_SPU_PPU64)
4971             *wrel++ = *rel;
4972         }
4973       input_section->reloc_count = wrel - relocs;
4974       /* Backflips for _bfd_elf_link_output_relocs.  */
4975       rel_hdr = &elf_section_data (input_section)->rel_hdr;
4976       rel_hdr->sh_size = input_section->reloc_count * rel_hdr->sh_entsize;
4977       ret = 2;
4978     }
4979
4980   return ret;
4981 }
4982
4983 /* Adjust _SPUEAR_ syms to point at their overlay stubs.  */
4984
4985 static bfd_boolean
4986 spu_elf_output_symbol_hook (struct bfd_link_info *info,
4987                             const char *sym_name ATTRIBUTE_UNUSED,
4988                             Elf_Internal_Sym *sym,
4989                             asection *sym_sec ATTRIBUTE_UNUSED,
4990                             struct elf_link_hash_entry *h)
4991 {
4992   struct spu_link_hash_table *htab = spu_hash_table (info);
4993
4994   if (!info->relocatable
4995       && htab->stub_sec != NULL
4996       && h != NULL
4997       && (h->root.type == bfd_link_hash_defined
4998           || h->root.type == bfd_link_hash_defweak)
4999       && h->def_regular
5000       && strncmp (h->root.root.string, "_SPUEAR_", 8) == 0)
5001     {
5002       struct got_entry *g;
5003
5004       for (g = h->got.glist; g != NULL; g = g->next)
5005         if (htab->params->ovly_flavour == ovly_soft_icache
5006             ? g->br_addr == g->stub_addr
5007             : g->addend == 0 && g->ovl == 0)
5008           {
5009             sym->st_shndx = (_bfd_elf_section_from_bfd_section
5010                              (htab->stub_sec[0]->output_section->owner,
5011                               htab->stub_sec[0]->output_section));
5012             sym->st_value = g->stub_addr;
5013             break;
5014           }
5015     }
5016
5017   return TRUE;
5018 }
5019
5020 static int spu_plugin = 0;
5021
5022 void
5023 spu_elf_plugin (int val)
5024 {
5025   spu_plugin = val;
5026 }
5027
5028 /* Set ELF header e_type for plugins.  */
5029
5030 static void
5031 spu_elf_post_process_headers (bfd *abfd,
5032                               struct bfd_link_info *info ATTRIBUTE_UNUSED)
5033 {
5034   if (spu_plugin)
5035     {
5036       Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
5037
5038       i_ehdrp->e_type = ET_DYN;
5039     }
5040 }
5041
5042 /* We may add an extra PT_LOAD segment for .toe.  We also need extra
5043    segments for overlays.  */
5044
5045 static int
5046 spu_elf_additional_program_headers (bfd *abfd, struct bfd_link_info *info)
5047 {
5048   int extra = 0;
5049   asection *sec;
5050
5051   if (info != NULL)
5052     {
5053       struct spu_link_hash_table *htab = spu_hash_table (info);
5054       extra = htab->num_overlays;
5055     }
5056
5057   if (extra)
5058     ++extra;
5059
5060   sec = bfd_get_section_by_name (abfd, ".toe");
5061   if (sec != NULL && (sec->flags & SEC_LOAD) != 0)
5062     ++extra;
5063
5064   return extra;
5065 }
5066
5067 /* Remove .toe section from other PT_LOAD segments and put it in
5068    a segment of its own.  Put overlays in separate segments too.  */
5069
5070 static bfd_boolean
5071 spu_elf_modify_segment_map (bfd *abfd, struct bfd_link_info *info)
5072 {
5073   asection *toe, *s;
5074   struct elf_segment_map *m, *m_overlay;
5075   struct elf_segment_map **p, **p_overlay;
5076   unsigned int i;
5077
5078   if (info == NULL)
5079     return TRUE;
5080
5081   toe = bfd_get_section_by_name (abfd, ".toe");
5082   for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
5083     if (m->p_type == PT_LOAD && m->count > 1)
5084       for (i = 0; i < m->count; i++)
5085         if ((s = m->sections[i]) == toe
5086             || spu_elf_section_data (s)->u.o.ovl_index != 0)
5087           {
5088             struct elf_segment_map *m2;
5089             bfd_vma amt;
5090
5091             if (i + 1 < m->count)
5092               {
5093                 amt = sizeof (struct elf_segment_map);
5094                 amt += (m->count - (i + 2)) * sizeof (m->sections[0]);
5095                 m2 = bfd_zalloc (abfd, amt);
5096                 if (m2 == NULL)
5097                   return FALSE;
5098                 m2->count = m->count - (i + 1);
5099                 memcpy (m2->sections, m->sections + i + 1,
5100                         m2->count * sizeof (m->sections[0]));
5101                 m2->p_type = PT_LOAD;
5102                 m2->next = m->next;
5103                 m->next = m2;
5104               }
5105             m->count = 1;
5106             if (i != 0)
5107               {
5108                 m->count = i;
5109                 amt = sizeof (struct elf_segment_map);
5110                 m2 = bfd_zalloc (abfd, amt);
5111                 if (m2 == NULL)
5112                   return FALSE;
5113                 m2->p_type = PT_LOAD;
5114                 m2->count = 1;
5115                 m2->sections[0] = s;
5116                 m2->next = m->next;
5117                 m->next = m2;
5118               }
5119             break;
5120           }
5121
5122
5123   /* Some SPU ELF loaders ignore the PF_OVERLAY flag and just load all
5124      PT_LOAD segments.  This can cause the .ovl.init section to be
5125      overwritten with the contents of some overlay segment.  To work
5126      around this issue, we ensure that all PF_OVERLAY segments are
5127      sorted first amongst the program headers; this ensures that even
5128      with a broken loader, the .ovl.init section (which is not marked
5129      as PF_OVERLAY) will be placed into SPU local store on startup.  */
5130
5131   /* Move all overlay segments onto a separate list.  */
5132   p = &elf_tdata (abfd)->segment_map;
5133   p_overlay = &m_overlay;
5134   while (*p != NULL)
5135     {
5136       if ((*p)->p_type == PT_LOAD && (*p)->count == 1
5137           && spu_elf_section_data ((*p)->sections[0])->u.o.ovl_index != 0)
5138         {
5139           struct elf_segment_map *m = *p;
5140           *p = m->next;
5141           *p_overlay = m;
5142           p_overlay = &m->next;
5143           continue;
5144         }
5145
5146       p = &((*p)->next);
5147     }
5148
5149   /* Re-insert overlay segments at the head of the segment map.  */
5150   *p_overlay = elf_tdata (abfd)->segment_map;
5151   elf_tdata (abfd)->segment_map = m_overlay;
5152
5153   return TRUE;
5154 }
5155
5156 /* Tweak the section type of .note.spu_name.  */
5157
5158 static bfd_boolean
5159 spu_elf_fake_sections (bfd *obfd ATTRIBUTE_UNUSED,
5160                        Elf_Internal_Shdr *hdr,
5161                        asection *sec)
5162 {
5163   if (strcmp (sec->name, SPU_PTNOTE_SPUNAME) == 0)
5164     hdr->sh_type = SHT_NOTE;
5165   return TRUE;
5166 }
5167
5168 /* Tweak phdrs before writing them out.  */
5169
5170 static int
5171 spu_elf_modify_program_headers (bfd *abfd, struct bfd_link_info *info)
5172 {
5173   const struct elf_backend_data *bed;
5174   struct elf_obj_tdata *tdata;
5175   Elf_Internal_Phdr *phdr, *last;
5176   struct spu_link_hash_table *htab;
5177   unsigned int count;
5178   unsigned int i;
5179
5180   if (info == NULL)
5181     return TRUE;
5182
5183   bed = get_elf_backend_data (abfd);
5184   tdata = elf_tdata (abfd);
5185   phdr = tdata->phdr;
5186   count = tdata->program_header_size / bed->s->sizeof_phdr;
5187   htab = spu_hash_table (info);
5188   if (htab->num_overlays != 0)
5189     {
5190       struct elf_segment_map *m;
5191       unsigned int o;
5192
5193       for (i = 0, m = elf_tdata (abfd)->segment_map; m; ++i, m = m->next)
5194         if (m->count != 0
5195             && (o = spu_elf_section_data (m->sections[0])->u.o.ovl_index) != 0)
5196           {
5197             /* Mark this as an overlay header.  */
5198             phdr[i].p_flags |= PF_OVERLAY;
5199
5200             if (htab->ovtab != NULL && htab->ovtab->size != 0
5201                 && htab->params->ovly_flavour != ovly_soft_icache)
5202               {
5203                 bfd_byte *p = htab->ovtab->contents;
5204                 unsigned int off = o * 16 + 8;
5205
5206                 /* Write file_off into _ovly_table.  */
5207                 bfd_put_32 (htab->ovtab->owner, phdr[i].p_offset, p + off);
5208               }
5209           }
5210       /* Soft-icache has its file offset put in .ovl.init.  */
5211       if (htab->init != NULL && htab->init->size != 0)
5212         {
5213           bfd_vma val = elf_section_data (htab->ovl_sec[0])->this_hdr.sh_offset;
5214
5215           bfd_put_32 (htab->init->owner, val, htab->init->contents + 4);
5216         }
5217     }
5218
5219   /* Round up p_filesz and p_memsz of PT_LOAD segments to multiples
5220      of 16.  This should always be possible when using the standard
5221      linker scripts, but don't create overlapping segments if
5222      someone is playing games with linker scripts.  */
5223   last = NULL;
5224   for (i = count; i-- != 0; )
5225     if (phdr[i].p_type == PT_LOAD)
5226       {
5227         unsigned adjust;
5228
5229         adjust = -phdr[i].p_filesz & 15;
5230         if (adjust != 0
5231             && last != NULL
5232             && phdr[i].p_offset + phdr[i].p_filesz > last->p_offset - adjust)
5233           break;
5234
5235         adjust = -phdr[i].p_memsz & 15;
5236         if (adjust != 0
5237             && last != NULL
5238             && phdr[i].p_filesz != 0
5239             && phdr[i].p_vaddr + phdr[i].p_memsz > last->p_vaddr - adjust
5240             && phdr[i].p_vaddr + phdr[i].p_memsz <= last->p_vaddr)
5241           break;
5242
5243         if (phdr[i].p_filesz != 0)
5244           last = &phdr[i];
5245       }
5246
5247   if (i == (unsigned int) -1)
5248     for (i = count; i-- != 0; )
5249       if (phdr[i].p_type == PT_LOAD)
5250         {
5251         unsigned adjust;
5252
5253         adjust = -phdr[i].p_filesz & 15;
5254         phdr[i].p_filesz += adjust;
5255
5256         adjust = -phdr[i].p_memsz & 15;
5257         phdr[i].p_memsz += adjust;
5258       }
5259
5260   return TRUE;
5261 }
5262
5263 #define TARGET_BIG_SYM          bfd_elf32_spu_vec
5264 #define TARGET_BIG_NAME         "elf32-spu"
5265 #define ELF_ARCH                bfd_arch_spu
5266 #define ELF_MACHINE_CODE        EM_SPU
5267 /* This matches the alignment need for DMA.  */
5268 #define ELF_MAXPAGESIZE         0x80
5269 #define elf_backend_rela_normal         1
5270 #define elf_backend_can_gc_sections     1
5271
5272 #define bfd_elf32_bfd_reloc_type_lookup         spu_elf_reloc_type_lookup
5273 #define bfd_elf32_bfd_reloc_name_lookup         spu_elf_reloc_name_lookup
5274 #define elf_info_to_howto                       spu_elf_info_to_howto
5275 #define elf_backend_count_relocs                spu_elf_count_relocs
5276 #define elf_backend_relocate_section            spu_elf_relocate_section
5277 #define elf_backend_symbol_processing           spu_elf_backend_symbol_processing
5278 #define elf_backend_link_output_symbol_hook     spu_elf_output_symbol_hook
5279 #define elf_backend_object_p                    spu_elf_object_p
5280 #define bfd_elf32_new_section_hook              spu_elf_new_section_hook
5281 #define bfd_elf32_bfd_link_hash_table_create    spu_elf_link_hash_table_create
5282
5283 #define elf_backend_additional_program_headers  spu_elf_additional_program_headers
5284 #define elf_backend_modify_segment_map          spu_elf_modify_segment_map
5285 #define elf_backend_modify_program_headers      spu_elf_modify_program_headers
5286 #define elf_backend_post_process_headers        spu_elf_post_process_headers
5287 #define elf_backend_fake_sections               spu_elf_fake_sections
5288 #define elf_backend_special_sections            spu_elf_special_sections
5289 #define bfd_elf32_bfd_final_link                spu_elf_final_link
5290
5291 #include "elf32-target.h"