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