bfd/elf32-spu.c

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