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